serialize.go

   1 // Code generated by mkserialize.sh; DO NOT EDIT.
   2
   3 package mt
   4
   5 import (
   6         "bytes"
   7         "compress/zlib"
   8         "errors"
   9         "fmt"
  10         "image/color"
  11         "io"
  12         "math"
  13         "sort"
  14         "unicode/utf16"
  15
  16         "github.com/klauspost/compress/zstd"
  17 )
  18
  19 func write8(w io.Writer, x uint8) {
  20         _, err := w.Write([]byte{x})
  21         chk(err)
  22 }
  23 func write16(w io.Writer, x uint16) {
  24         buf := make([]byte, 2)
  25         be.PutUint16(buf, x)
  26         _, err := w.Write(buf)
  27         chk(err)
  28 }
  29 func write32(w io.Writer, x uint32) {
  30         buf := make([]byte, 4)
  31         be.PutUint32(buf, x)
  32         _, err := w.Write(buf)
  33         chk(err)
  34 }
  35 func write64(w io.Writer, x uint64) {
  36         buf := make([]byte, 8)
  37         be.PutUint64(buf, x)
  38         _, err := w.Write(buf)
  39         chk(err)
  40 }
  41 func readBuf(r io.Reader, n int) []byte {
  42         buf := make([]byte, n)
  43         _, err := io.ReadFull(r, buf)
  44         chk(err)
  45         return buf
  46 }
  47 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  48 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  49 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  50 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  51
  52 func (obj *ToSrvNil) serialize(w io.Writer) {
  53 }
  54
  55 func (obj *ToSrvNil) deserialize(r io.Reader) {
  56 }
  57
  58 func (obj *ToSrvInit) serialize(w io.Writer) {
  59         {
  60                 x := (*(*(struct {
  61                         SerializeVer             uint8
  62                         SupportedCompression     CompressionModes
  63                         MinProtoVer, MaxProtoVer uint16
  64                         PlayerName               string
  65
  66                         //mt:opt
  67                         SendFullItemMeta bool
  68                 }))(obj)).SerializeVer
  69                 write8(w, uint8(x))
  70         }
  71         if err := pcall(func() {
  72                 ((*(*(struct {
  73                         SerializeVer             uint8
  74                         SupportedCompression     CompressionModes
  75                         MinProtoVer, MaxProtoVer uint16
  76                         PlayerName               string
  77
  78                         //mt:opt
  79                         SendFullItemMeta bool
  80                 }))(obj)).SupportedCompression).serialize(w)
  81         }); err != nil {
  82                 if err == io.EOF {
  83                         chk(io.EOF)
  84                 }
  85                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
  86         }
  87         {
  88                 x := (*(*(struct {
  89                         SerializeVer             uint8
  90                         SupportedCompression     CompressionModes
  91                         MinProtoVer, MaxProtoVer uint16
  92                         PlayerName               string
  93
  94                         //mt:opt
  95                         SendFullItemMeta bool
  96                 }))(obj)).MinProtoVer
  97                 write16(w, uint16(x))
  98         }
  99         {
 100                 x := (*(*(struct {
 101                         SerializeVer             uint8
 102                         SupportedCompression     CompressionModes
 103                         MinProtoVer, MaxProtoVer uint16
 104                         PlayerName               string
 105
 106                         //mt:opt
 107                         SendFullItemMeta bool
 108                 }))(obj)).MaxProtoVer
 109                 write16(w, uint16(x))
 110         }
 111         if len(([]byte((*(*(struct {
 112                 SerializeVer             uint8
 113                 SupportedCompression     CompressionModes
 114                 MinProtoVer, MaxProtoVer uint16
 115                 PlayerName               string
 116
 117                 //mt:opt
 118                 SendFullItemMeta bool
 119         }))(obj)).PlayerName))) > math.MaxUint16 {
 120                 chk(ErrTooLong)
 121         }
 122         {
 123                 x := uint16(len(([]byte((*(*(struct {
 124                         SerializeVer             uint8
 125                         SupportedCompression     CompressionModes
 126                         MinProtoVer, MaxProtoVer uint16
 127                         PlayerName               string
 128
 129                         //mt:opt
 130                         SendFullItemMeta bool
 131                 }))(obj)).PlayerName))))
 132                 write16(w, uint16(x))
 133         }
 134         {
 135                 _, err := w.Write(([]byte((*(*(struct {
 136                         SerializeVer             uint8
 137                         SupportedCompression     CompressionModes
 138                         MinProtoVer, MaxProtoVer uint16
 139                         PlayerName               string
 140
 141                         //mt:opt
 142                         SendFullItemMeta bool
 143                 }))(obj)).PlayerName))[:])
 144                 chk(err)
 145         }
 146         if err := pcall(func() {
 147                 {
 148                         x := (*(*(struct {
 149                                 SerializeVer             uint8
 150                                 SupportedCompression     CompressionModes
 151                                 MinProtoVer, MaxProtoVer uint16
 152                                 PlayerName               string
 153
 154                                 //mt:opt
 155                                 SendFullItemMeta bool
 156                         }))(obj)).SendFullItemMeta
 157                         if x {
 158                                 write8(w, 1)
 159                         } else {
 160                                 write8(w, 0)
 161                         }
 162                 }
 163         }); err != nil && err != io.EOF {
 164                 chk(err)
 165         }
 166 }
 167
 168 func (obj *ToSrvInit) deserialize(r io.Reader) {
 169         {
 170                 p := &(*(*(struct {
 171                         SerializeVer             uint8
 172                         SupportedCompression     CompressionModes
 173                         MinProtoVer, MaxProtoVer uint16
 174                         PlayerName               string
 175
 176                         //mt:opt
 177                         SendFullItemMeta bool
 178                 }))(obj)).SerializeVer
 179                 *p = read8(r)
 180         }
 181         if err := pcall(func() {
 182                 ((*(*(struct {
 183                         SerializeVer             uint8
 184                         SupportedCompression     CompressionModes
 185                         MinProtoVer, MaxProtoVer uint16
 186                         PlayerName               string
 187
 188                         //mt:opt
 189                         SendFullItemMeta bool
 190                 }))(obj)).SupportedCompression).deserialize(r)
 191         }); err != nil {
 192                 if err == io.EOF {
 193                         chk(io.EOF)
 194                 }
 195                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
 196         }
 197         {
 198                 p := &(*(*(struct {
 199                         SerializeVer             uint8
 200                         SupportedCompression     CompressionModes
 201                         MinProtoVer, MaxProtoVer uint16
 202                         PlayerName               string
 203
 204                         //mt:opt
 205                         SendFullItemMeta bool
 206                 }))(obj)).MinProtoVer
 207                 *p = read16(r)
 208         }
 209         {
 210                 p := &(*(*(struct {
 211                         SerializeVer             uint8
 212                         SupportedCompression     CompressionModes
 213                         MinProtoVer, MaxProtoVer uint16
 214                         PlayerName               string
 215
 216                         //mt:opt
 217                         SendFullItemMeta bool
 218                 }))(obj)).MaxProtoVer
 219                 *p = read16(r)
 220         }
 221         var local1 []uint8
 222         var local2 uint16
 223         {
 224                 p := &local2
 225                 *p = read16(r)
 226         }
 227         (local1) = make([]uint8, local2)
 228         {
 229                 _, err := io.ReadFull(r, (local1)[:])
 230                 chk(err)
 231         }
 232         ((*(*(struct {
 233                 SerializeVer             uint8
 234                 SupportedCompression     CompressionModes
 235                 MinProtoVer, MaxProtoVer uint16
 236                 PlayerName               string
 237
 238                 //mt:opt
 239                 SendFullItemMeta bool
 240         }))(obj)).PlayerName) = string(local1)
 241         if err := pcall(func() {
 242                 {
 243                         p := &(*(*(struct {
 244                                 SerializeVer             uint8
 245                                 SupportedCompression     CompressionModes
 246                                 MinProtoVer, MaxProtoVer uint16
 247                                 PlayerName               string
 248
 249                                 //mt:opt
 250                                 SendFullItemMeta bool
 251                         }))(obj)).SendFullItemMeta
 252                         switch n := read8(r); n {
 253                         case 0:
 254                                 *p = false
 255                         case 1:
 256                                 *p = true
 257                         default:
 258                                 chk(fmt.Errorf("invalid bool: %d", n))
 259                         }
 260                 }
 261         }); err != nil && err != io.EOF {
 262                 chk(err)
 263         }
 264 }
 265
 266 func (obj *ToSrvInit2) serialize(w io.Writer) {
 267         if len(([]byte((*(*(struct {
 268                 Lang string
 269         }))(obj)).Lang))) > math.MaxUint16 {
 270                 chk(ErrTooLong)
 271         }
 272         {
 273                 x := uint16(len(([]byte((*(*(struct {
 274                         Lang string
 275                 }))(obj)).Lang))))
 276                 write16(w, uint16(x))
 277         }
 278         {
 279                 _, err := w.Write(([]byte((*(*(struct {
 280                         Lang string
 281                 }))(obj)).Lang))[:])
 282                 chk(err)
 283         }
 284 }
 285
 286 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 287         var local3 []uint8
 288         var local4 uint16
 289         {
 290                 p := &local4
 291                 *p = read16(r)
 292         }
 293         (local3) = make([]uint8, local4)
 294         {
 295                 _, err := io.ReadFull(r, (local3)[:])
 296                 chk(err)
 297         }
 298         ((*(*(struct {
 299                 Lang string
 300         }))(obj)).Lang) = string(local3)
 301 }
 302
 303 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 304         if len(([]byte((*(*(struct {
 305                 Channel string
 306         }))(obj)).Channel))) > math.MaxUint16 {
 307                 chk(ErrTooLong)
 308         }
 309         {
 310                 x := uint16(len(([]byte((*(*(struct {
 311                         Channel string
 312                 }))(obj)).Channel))))
 313                 write16(w, uint16(x))
 314         }
 315         {
 316                 _, err := w.Write(([]byte((*(*(struct {
 317                         Channel string
 318                 }))(obj)).Channel))[:])
 319                 chk(err)
 320         }
 321 }
 322
 323 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 324         var local5 []uint8
 325         var local6 uint16
 326         {
 327                 p := &local6
 328                 *p = read16(r)
 329         }
 330         (local5) = make([]uint8, local6)
 331         {
 332                 _, err := io.ReadFull(r, (local5)[:])
 333                 chk(err)
 334         }
 335         ((*(*(struct {
 336                 Channel string
 337         }))(obj)).Channel) = string(local5)
 338 }
 339
 340 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 341         if len(([]byte((*(*(struct {
 342                 Channel string
 343         }))(obj)).Channel))) > math.MaxUint16 {
 344                 chk(ErrTooLong)
 345         }
 346         {
 347                 x := uint16(len(([]byte((*(*(struct {
 348                         Channel string
 349                 }))(obj)).Channel))))
 350                 write16(w, uint16(x))
 351         }
 352         {
 353                 _, err := w.Write(([]byte((*(*(struct {
 354                         Channel string
 355                 }))(obj)).Channel))[:])
 356                 chk(err)
 357         }
 358 }
 359
 360 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 361         var local7 []uint8
 362         var local8 uint16
 363         {
 364                 p := &local8
 365                 *p = read16(r)
 366         }
 367         (local7) = make([]uint8, local8)
 368         {
 369                 _, err := io.ReadFull(r, (local7)[:])
 370                 chk(err)
 371         }
 372         ((*(*(struct {
 373                 Channel string
 374         }))(obj)).Channel) = string(local7)
 375 }
 376
 377 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 378         if len(([]byte((*(*(struct {
 379                 Channel string
 380                 Msg     string
 381         }))(obj)).Channel))) > math.MaxUint16 {
 382                 chk(ErrTooLong)
 383         }
 384         {
 385                 x := uint16(len(([]byte((*(*(struct {
 386                         Channel string
 387                         Msg     string
 388                 }))(obj)).Channel))))
 389                 write16(w, uint16(x))
 390         }
 391         {
 392                 _, err := w.Write(([]byte((*(*(struct {
 393                         Channel string
 394                         Msg     string
 395                 }))(obj)).Channel))[:])
 396                 chk(err)
 397         }
 398         if len(([]byte((*(*(struct {
 399                 Channel string
 400                 Msg     string
 401         }))(obj)).Msg))) > math.MaxUint16 {
 402                 chk(ErrTooLong)
 403         }
 404         {
 405                 x := uint16(len(([]byte((*(*(struct {
 406                         Channel string
 407                         Msg     string
 408                 }))(obj)).Msg))))
 409                 write16(w, uint16(x))
 410         }
 411         {
 412                 _, err := w.Write(([]byte((*(*(struct {
 413                         Channel string
 414                         Msg     string
 415                 }))(obj)).Msg))[:])
 416                 chk(err)
 417         }
 418 }
 419
 420 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 421         var local9 []uint8
 422         var local10 uint16
 423         {
 424                 p := &local10
 425                 *p = read16(r)
 426         }
 427         (local9) = make([]uint8, local10)
 428         {
 429                 _, err := io.ReadFull(r, (local9)[:])
 430                 chk(err)
 431         }
 432         ((*(*(struct {
 433                 Channel string
 434                 Msg     string
 435         }))(obj)).Channel) = string(local9)
 436         var local11 []uint8
 437         var local12 uint16
 438         {
 439                 p := &local12
 440                 *p = read16(r)
 441         }
 442         (local11) = make([]uint8, local12)
 443         {
 444                 _, err := io.ReadFull(r, (local11)[:])
 445                 chk(err)
 446         }
 447         ((*(*(struct {
 448                 Channel string
 449                 Msg     string
 450         }))(obj)).Msg) = string(local11)
 451 }
 452
 453 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 454         if err := pcall(func() {
 455                 ((*(*(struct {
 456                         Pos PlayerPos
 457                 }))(obj)).Pos).serialize(w)
 458         }); err != nil {
 459                 if err == io.EOF {
 460                         chk(io.EOF)
 461                 }
 462                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 463         }
 464 }
 465
 466 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 467         if err := pcall(func() {
 468                 ((*(*(struct {
 469                         Pos PlayerPos
 470                 }))(obj)).Pos).deserialize(r)
 471         }); err != nil {
 472                 if err == io.EOF {
 473                         chk(io.EOF)
 474                 }
 475                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 476         }
 477 }
 478
 479 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 480         if len(((*(*(struct {
 481                 //mt:len8
 482                 Blks [][3]int16
 483         }))(obj)).Blks)) > math.MaxUint8 {
 484                 chk(ErrTooLong)
 485         }
 486         {
 487                 x := uint8(len(((*(*(struct {
 488                         //mt:len8
 489                         Blks [][3]int16
 490                 }))(obj)).Blks)))
 491                 write8(w, uint8(x))
 492         }
 493         for local13 := range (*(*(struct {
 494                 //mt:len8
 495                 Blks [][3]int16
 496         }))(obj)).Blks {
 497                 for local14 := range ((*(*(struct {
 498                         //mt:len8
 499                         Blks [][3]int16
 500                 }))(obj)).Blks)[local13] {
 501                         {
 502                                 x := (((*(*(struct {
 503                                         //mt:len8
 504                                         Blks [][3]int16
 505                                 }))(obj)).Blks)[local13])[local14]
 506                                 write16(w, uint16(x))
 507                         }
 508                 }
 509         }
 510 }
 511
 512 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 513         var local15 uint8
 514         {
 515                 p := &local15
 516                 *p = read8(r)
 517         }
 518         ((*(*(struct {
 519                 //mt:len8
 520                 Blks [][3]int16
 521         }))(obj)).Blks) = make([][3]int16, local15)
 522         for local16 := range (*(*(struct {
 523                 //mt:len8
 524                 Blks [][3]int16
 525         }))(obj)).Blks {
 526                 for local17 := range ((*(*(struct {
 527                         //mt:len8
 528                         Blks [][3]int16
 529                 }))(obj)).Blks)[local16] {
 530                         {
 531                                 p := &(((*(*(struct {
 532                                         //mt:len8
 533                                         Blks [][3]int16
 534                                 }))(obj)).Blks)[local16])[local17]
 535                                 *p = int16(read16(r))
 536                         }
 537                 }
 538         }
 539 }
 540
 541 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 542         if len(((*(*(struct {
 543                 //mt:len8
 544                 Blks [][3]int16
 545         }))(obj)).Blks)) > math.MaxUint8 {
 546                 chk(ErrTooLong)
 547         }
 548         {
 549                 x := uint8(len(((*(*(struct {
 550                         //mt:len8
 551                         Blks [][3]int16
 552                 }))(obj)).Blks)))
 553                 write8(w, uint8(x))
 554         }
 555         for local18 := range (*(*(struct {
 556                 //mt:len8
 557                 Blks [][3]int16
 558         }))(obj)).Blks {
 559                 for local19 := range ((*(*(struct {
 560                         //mt:len8
 561                         Blks [][3]int16
 562                 }))(obj)).Blks)[local18] {
 563                         {
 564                                 x := (((*(*(struct {
 565                                         //mt:len8
 566                                         Blks [][3]int16
 567                                 }))(obj)).Blks)[local18])[local19]
 568                                 write16(w, uint16(x))
 569                         }
 570                 }
 571         }
 572 }
 573
 574 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 575         var local20 uint8
 576         {
 577                 p := &local20
 578                 *p = read8(r)
 579         }
 580         ((*(*(struct {
 581                 //mt:len8
 582                 Blks [][3]int16
 583         }))(obj)).Blks) = make([][3]int16, local20)
 584         for local21 := range (*(*(struct {
 585                 //mt:len8
 586                 Blks [][3]int16
 587         }))(obj)).Blks {
 588                 for local22 := range ((*(*(struct {
 589                         //mt:len8
 590                         Blks [][3]int16
 591                 }))(obj)).Blks)[local21] {
 592                         {
 593                                 p := &(((*(*(struct {
 594                                         //mt:len8
 595                                         Blks [][3]int16
 596                                 }))(obj)).Blks)[local21])[local22]
 597                                 *p = int16(read16(r))
 598                         }
 599                 }
 600         }
 601 }
 602
 603 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 604         {
 605                 _, err := w.Write(([]byte((*(*(struct {
 606                         //mt:raw
 607                         Action string
 608                 }))(obj)).Action))[:])
 609                 chk(err)
 610         }
 611 }
 612
 613 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 614         var local23 []uint8
 615         {
 616                 var err error
 617                 (local23), err = io.ReadAll(r)
 618                 chk(err)
 619         }
 620         ((*(*(struct {
 621                 //mt:raw
 622                 Action string
 623         }))(obj)).Action) = string(local23)
 624 }
 625
 626 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 627         local24 := utf16.Encode([]rune((*(*(struct {
 628                 //mt:utf16
 629                 Msg string
 630         }))(obj)).Msg))
 631         if len((local24)) > math.MaxUint16 {
 632                 chk(ErrTooLong)
 633         }
 634         {
 635                 x := uint16(len((local24)))
 636                 write16(w, uint16(x))
 637         }
 638         for local25 := range local24 {
 639                 {
 640                         x := (local24)[local25]
 641                         write16(w, uint16(x))
 642                 }
 643         }
 644 }
 645
 646 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 647         var local26 []uint16
 648         var local27 uint16
 649         {
 650                 p := &local27
 651                 *p = read16(r)
 652         }
 653         (local26) = make([]uint16, local27)
 654         for local28 := range local26 {
 655                 {
 656                         p := &(local26)[local28]
 657                         *p = read16(r)
 658                 }
 659         }
 660         (*(*(struct {
 661                 //mt:utf16
 662                 Msg string
 663         }))(obj)).Msg = string(utf16.Decode(local26))
 664 }
 665
 666 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 667         {
 668                 x := (*(*(struct {
 669                         Amount uint16
 670                 }))(obj)).Amount
 671                 write16(w, uint16(x))
 672         }
 673 }
 674
 675 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 676         {
 677                 p := &(*(*(struct {
 678                         Amount uint16
 679                 }))(obj)).Amount
 680                 *p = read16(r)
 681         }
 682 }
 683
 684 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 685         {
 686                 x := (*(*(struct {
 687                         Slot uint16
 688                 }))(obj)).Slot
 689                 write16(w, uint16(x))
 690         }
 691 }
 692
 693 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 694         {
 695                 p := &(*(*(struct {
 696                         Slot uint16
 697                 }))(obj)).Slot
 698                 *p = read16(r)
 699         }
 700 }
 701
 702 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 703 }
 704
 705 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 706 }
 707
 708 func (obj *ToSrvInteract) serialize(w io.Writer) {
 709         if err := pcall(func() {
 710                 ((*(*(struct {
 711                         Action   Interaction
 712                         ItemSlot uint16
 713                         //mt:lenhdr 32
 714                         Pointed PointedThing
 715                         //mt:end
 716                         Pos PlayerPos
 717                 }))(obj)).Action).serialize(w)
 718         }); err != nil {
 719                 if err == io.EOF {
 720                         chk(io.EOF)
 721                 }
 722                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Interaction", err))
 723         }
 724         {
 725                 x := (*(*(struct {
 726                         Action   Interaction
 727                         ItemSlot uint16
 728                         //mt:lenhdr 32
 729                         Pointed PointedThing
 730                         //mt:end
 731                         Pos PlayerPos
 732                 }))(obj)).ItemSlot
 733                 write16(w, uint16(x))
 734         }
 735         {
 736                 ow := w
 737                 w := new(bytes.Buffer)
 738                 {
 739                         x := (*(*(struct {
 740                                 Action   Interaction
 741                                 ItemSlot uint16
 742                                 //mt:lenhdr 32
 743                                 Pointed PointedThing
 744                                 //mt:end
 745                                 Pos PlayerPos
 746                         }))(obj)).Pointed
 747                         chk(writePointedThing(w, x))
 748                 }
 749                 {
 750                         buf := w
 751                         w := ow
 752                         if len((buf.Bytes())) > math.MaxUint32 {
 753                                 chk(ErrTooLong)
 754                         }
 755                         {
 756                                 x := uint32(len((buf.Bytes())))
 757                                 write32(w, uint32(x))
 758                         }
 759                         {
 760                                 _, err := w.Write((buf.Bytes())[:])
 761                                 chk(err)
 762                         }
 763                 }
 764         }
 765         if err := pcall(func() {
 766                 ((*(*(struct {
 767                         Action   Interaction
 768                         ItemSlot uint16
 769                         //mt:lenhdr 32
 770                         Pointed PointedThing
 771                         //mt:end
 772                         Pos PlayerPos
 773                 }))(obj)).Pos).serialize(w)
 774         }); err != nil {
 775                 if err == io.EOF {
 776                         chk(io.EOF)
 777                 }
 778                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 779         }
 780 }
 781
 782 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 783         if err := pcall(func() {
 784                 ((*(*(struct {
 785                         Action   Interaction
 786                         ItemSlot uint16
 787                         //mt:lenhdr 32
 788                         Pointed PointedThing
 789                         //mt:end
 790                         Pos PlayerPos
 791                 }))(obj)).Action).deserialize(r)
 792         }); err != nil {
 793                 if err == io.EOF {
 794                         chk(io.EOF)
 795                 }
 796                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Interaction", err))
 797         }
 798         {
 799                 p := &(*(*(struct {
 800                         Action   Interaction
 801                         ItemSlot uint16
 802                         //mt:lenhdr 32
 803                         Pointed PointedThing
 804                         //mt:end
 805                         Pos PlayerPos
 806                 }))(obj)).ItemSlot
 807                 *p = read16(r)
 808         }
 809         {
 810                 var n uint32
 811                 {
 812                         p := &n
 813                         *p = read32(r)
 814                 }
 815                 r := &io.LimitedReader{R: r, N: int64(n)}
 816                 {
 817                         p := &(*(*(struct {
 818                                 Action   Interaction
 819                                 ItemSlot uint16
 820                                 //mt:lenhdr 32
 821                                 Pointed PointedThing
 822                                 //mt:end
 823                                 Pos PlayerPos
 824                         }))(obj)).Pointed
 825                         {
 826                                 var err error
 827                                 *p, err = readPointedThing(r)
 828                                 chk(err)
 829                         }
 830                 }
 831                 if r.N > 0 {
 832                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 833                 }
 834         }
 835         if err := pcall(func() {
 836                 ((*(*(struct {
 837                         Action   Interaction
 838                         ItemSlot uint16
 839                         //mt:lenhdr 32
 840                         Pointed PointedThing
 841                         //mt:end
 842                         Pos PlayerPos
 843                 }))(obj)).Pos).deserialize(r)
 844         }); err != nil {
 845                 if err == io.EOF {
 846                         chk(io.EOF)
 847                 }
 848                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 849         }
 850 }
 851
 852 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 853         if len(((*(*(struct {
 854                 IDs []SoundID
 855         }))(obj)).IDs)) > math.MaxUint16 {
 856                 chk(ErrTooLong)
 857         }
 858         {
 859                 x := uint16(len(((*(*(struct {
 860                         IDs []SoundID
 861                 }))(obj)).IDs)))
 862                 write16(w, uint16(x))
 863         }
 864         for local29 := range (*(*(struct {
 865                 IDs []SoundID
 866         }))(obj)).IDs {
 867                 if err := pcall(func() {
 868                         (((*(*(struct {
 869                                 IDs []SoundID
 870                         }))(obj)).IDs)[local29]).serialize(w)
 871                 }); err != nil {
 872                         if err == io.EOF {
 873                                 chk(io.EOF)
 874                         }
 875                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
 876                 }
 877         }
 878 }
 879
 880 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 881         var local30 uint16
 882         {
 883                 p := &local30
 884                 *p = read16(r)
 885         }
 886         ((*(*(struct {
 887                 IDs []SoundID
 888         }))(obj)).IDs) = make([]SoundID, local30)
 889         for local31 := range (*(*(struct {
 890                 IDs []SoundID
 891         }))(obj)).IDs {
 892                 if err := pcall(func() {
 893                         (((*(*(struct {
 894                                 IDs []SoundID
 895                         }))(obj)).IDs)[local31]).deserialize(r)
 896                 }); err != nil {
 897                         if err == io.EOF {
 898                                 chk(io.EOF)
 899                         }
 900                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
 901                 }
 902         }
 903 }
 904
 905 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 906         for local32 := range (*(*(struct {
 907                 Pos      [3]int16
 908                 Formname string
 909                 Fields   []Field
 910         }))(obj)).Pos {
 911                 {
 912                         x := ((*(*(struct {
 913                                 Pos      [3]int16
 914                                 Formname string
 915                                 Fields   []Field
 916                         }))(obj)).Pos)[local32]
 917                         write16(w, uint16(x))
 918                 }
 919         }
 920         if len(([]byte((*(*(struct {
 921                 Pos      [3]int16
 922                 Formname string
 923                 Fields   []Field
 924         }))(obj)).Formname))) > math.MaxUint16 {
 925                 chk(ErrTooLong)
 926         }
 927         {
 928                 x := uint16(len(([]byte((*(*(struct {
 929                         Pos      [3]int16
 930                         Formname string
 931                         Fields   []Field
 932                 }))(obj)).Formname))))
 933                 write16(w, uint16(x))
 934         }
 935         {
 936                 _, err := w.Write(([]byte((*(*(struct {
 937                         Pos      [3]int16
 938                         Formname string
 939                         Fields   []Field
 940                 }))(obj)).Formname))[:])
 941                 chk(err)
 942         }
 943         if len(((*(*(struct {
 944                 Pos      [3]int16
 945                 Formname string
 946                 Fields   []Field
 947         }))(obj)).Fields)) > math.MaxUint16 {
 948                 chk(ErrTooLong)
 949         }
 950         {
 951                 x := uint16(len(((*(*(struct {
 952                         Pos      [3]int16
 953                         Formname string
 954                         Fields   []Field
 955                 }))(obj)).Fields)))
 956                 write16(w, uint16(x))
 957         }
 958         for local33 := range (*(*(struct {
 959                 Pos      [3]int16
 960                 Formname string
 961                 Fields   []Field
 962         }))(obj)).Fields {
 963                 if err := pcall(func() {
 964                         (((*(*(struct {
 965                                 Pos      [3]int16
 966                                 Formname string
 967                                 Fields   []Field
 968                         }))(obj)).Fields)[local33]).serialize(w)
 969                 }); err != nil {
 970                         if err == io.EOF {
 971                                 chk(io.EOF)
 972                         }
 973                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
 974                 }
 975         }
 976 }
 977
 978 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 979         for local34 := range (*(*(struct {
 980                 Pos      [3]int16
 981                 Formname string
 982                 Fields   []Field
 983         }))(obj)).Pos {
 984                 {
 985                         p := &((*(*(struct {
 986                                 Pos      [3]int16
 987                                 Formname string
 988                                 Fields   []Field
 989                         }))(obj)).Pos)[local34]
 990                         *p = int16(read16(r))
 991                 }
 992         }
 993         var local35 []uint8
 994         var local36 uint16
 995         {
 996                 p := &local36
 997                 *p = read16(r)
 998         }
 999         (local35) = make([]uint8, local36)
1000         {
1001                 _, err := io.ReadFull(r, (local35)[:])
1002                 chk(err)
1003         }
1004         ((*(*(struct {
1005                 Pos      [3]int16
1006                 Formname string
1007                 Fields   []Field
1008         }))(obj)).Formname) = string(local35)
1009         var local37 uint16
1010         {
1011                 p := &local37
1012                 *p = read16(r)
1013         }
1014         ((*(*(struct {
1015                 Pos      [3]int16
1016                 Formname string
1017                 Fields   []Field
1018         }))(obj)).Fields) = make([]Field, local37)
1019         for local38 := range (*(*(struct {
1020                 Pos      [3]int16
1021                 Formname string
1022                 Fields   []Field
1023         }))(obj)).Fields {
1024                 if err := pcall(func() {
1025                         (((*(*(struct {
1026                                 Pos      [3]int16
1027                                 Formname string
1028                                 Fields   []Field
1029                         }))(obj)).Fields)[local38]).deserialize(r)
1030                 }); err != nil {
1031                         if err == io.EOF {
1032                                 chk(io.EOF)
1033                         }
1034                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
1035                 }
1036         }
1037 }
1038
1039 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1040         if len(([]byte((*(*(struct {
1041                 Formname string
1042                 Fields   []Field
1043         }))(obj)).Formname))) > math.MaxUint16 {
1044                 chk(ErrTooLong)
1045         }
1046         {
1047                 x := uint16(len(([]byte((*(*(struct {
1048                         Formname string
1049                         Fields   []Field
1050                 }))(obj)).Formname))))
1051                 write16(w, uint16(x))
1052         }
1053         {
1054                 _, err := w.Write(([]byte((*(*(struct {
1055                         Formname string
1056                         Fields   []Field
1057                 }))(obj)).Formname))[:])
1058                 chk(err)
1059         }
1060         if len(((*(*(struct {
1061                 Formname string
1062                 Fields   []Field
1063         }))(obj)).Fields)) > math.MaxUint16 {
1064                 chk(ErrTooLong)
1065         }
1066         {
1067                 x := uint16(len(((*(*(struct {
1068                         Formname string
1069                         Fields   []Field
1070                 }))(obj)).Fields)))
1071                 write16(w, uint16(x))
1072         }
1073         for local39 := range (*(*(struct {
1074                 Formname string
1075                 Fields   []Field
1076         }))(obj)).Fields {
1077                 if err := pcall(func() {
1078                         (((*(*(struct {
1079                                 Formname string
1080                                 Fields   []Field
1081                         }))(obj)).Fields)[local39]).serialize(w)
1082                 }); err != nil {
1083                         if err == io.EOF {
1084                                 chk(io.EOF)
1085                         }
1086                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
1087                 }
1088         }
1089 }
1090
1091 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1092         var local40 []uint8
1093         var local41 uint16
1094         {
1095                 p := &local41
1096                 *p = read16(r)
1097         }
1098         (local40) = make([]uint8, local41)
1099         {
1100                 _, err := io.ReadFull(r, (local40)[:])
1101                 chk(err)
1102         }
1103         ((*(*(struct {
1104                 Formname string
1105                 Fields   []Field
1106         }))(obj)).Formname) = string(local40)
1107         var local42 uint16
1108         {
1109                 p := &local42
1110                 *p = read16(r)
1111         }
1112         ((*(*(struct {
1113                 Formname string
1114                 Fields   []Field
1115         }))(obj)).Fields) = make([]Field, local42)
1116         for local43 := range (*(*(struct {
1117                 Formname string
1118                 Fields   []Field
1119         }))(obj)).Fields {
1120                 if err := pcall(func() {
1121                         (((*(*(struct {
1122                                 Formname string
1123                                 Fields   []Field
1124                         }))(obj)).Fields)[local43]).deserialize(r)
1125                 }); err != nil {
1126                         if err == io.EOF {
1127                                 chk(io.EOF)
1128                         }
1129                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
1130                 }
1131         }
1132 }
1133
1134 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1135         if len(((*(*(struct {
1136                 Filenames []string
1137         }))(obj)).Filenames)) > math.MaxUint16 {
1138                 chk(ErrTooLong)
1139         }
1140         {
1141                 x := uint16(len(((*(*(struct {
1142                         Filenames []string
1143                 }))(obj)).Filenames)))
1144                 write16(w, uint16(x))
1145         }
1146         for local44 := range (*(*(struct {
1147                 Filenames []string
1148         }))(obj)).Filenames {
1149                 if len(([]byte(((*(*(struct {
1150                         Filenames []string
1151                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1152                         chk(ErrTooLong)
1153                 }
1154                 {
1155                         x := uint16(len(([]byte(((*(*(struct {
1156                                 Filenames []string
1157                         }))(obj)).Filenames)[local44]))))
1158                         write16(w, uint16(x))
1159                 }
1160                 {
1161                         _, err := w.Write(([]byte(((*(*(struct {
1162                                 Filenames []string
1163                         }))(obj)).Filenames)[local44]))[:])
1164                         chk(err)
1165                 }
1166         }
1167 }
1168
1169 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1170         var local45 uint16
1171         {
1172                 p := &local45
1173                 *p = read16(r)
1174         }
1175         ((*(*(struct {
1176                 Filenames []string
1177         }))(obj)).Filenames) = make([]string, local45)
1178         for local46 := range (*(*(struct {
1179                 Filenames []string
1180         }))(obj)).Filenames {
1181                 var local47 []uint8
1182                 var local48 uint16
1183                 {
1184                         p := &local48
1185                         *p = read16(r)
1186                 }
1187                 (local47) = make([]uint8, local48)
1188                 {
1189                         _, err := io.ReadFull(r, (local47)[:])
1190                         chk(err)
1191                 }
1192                 (((*(*(struct {
1193                         Filenames []string
1194                 }))(obj)).Filenames)[local46]) = string(local47)
1195         }
1196 }
1197
1198 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1199         {
1200                 x := (*(*(struct {
1201                         // Version information.
1202                         Major, Minor, Patch uint8
1203                         Reserved            uint8
1204                         Version             string
1205                         Formspec            uint16
1206                 }))(obj)).Major
1207                 write8(w, uint8(x))
1208         }
1209         {
1210                 x := (*(*(struct {
1211                         // Version information.
1212                         Major, Minor, Patch uint8
1213                         Reserved            uint8
1214                         Version             string
1215                         Formspec            uint16
1216                 }))(obj)).Minor
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)).Patch
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)).Reserved
1237                 write8(w, uint8(x))
1238         }
1239         if len(([]byte((*(*(struct {
1240                 // Version information.
1241                 Major, Minor, Patch uint8
1242                 Reserved            uint8
1243                 Version             string
1244                 Formspec            uint16
1245         }))(obj)).Version))) > math.MaxUint16 {
1246                 chk(ErrTooLong)
1247         }
1248         {
1249                 x := uint16(len(([]byte((*(*(struct {
1250                         // Version information.
1251                         Major, Minor, Patch uint8
1252                         Reserved            uint8
1253                         Version             string
1254                         Formspec            uint16
1255                 }))(obj)).Version))))
1256                 write16(w, uint16(x))
1257         }
1258         {
1259                 _, err := w.Write(([]byte((*(*(struct {
1260                         // Version information.
1261                         Major, Minor, Patch uint8
1262                         Reserved            uint8
1263                         Version             string
1264                         Formspec            uint16
1265                 }))(obj)).Version))[:])
1266                 chk(err)
1267         }
1268         {
1269                 x := (*(*(struct {
1270                         // Version information.
1271                         Major, Minor, Patch uint8
1272                         Reserved            uint8
1273                         Version             string
1274                         Formspec            uint16
1275                 }))(obj)).Formspec
1276                 write16(w, uint16(x))
1277         }
1278 }
1279
1280 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1281         {
1282                 p := &(*(*(struct {
1283                         // Version information.
1284                         Major, Minor, Patch uint8
1285                         Reserved            uint8
1286                         Version             string
1287                         Formspec            uint16
1288                 }))(obj)).Major
1289                 *p = read8(r)
1290         }
1291         {
1292                 p := &(*(*(struct {
1293                         // Version information.
1294                         Major, Minor, Patch uint8
1295                         Reserved            uint8
1296                         Version             string
1297                         Formspec            uint16
1298                 }))(obj)).Minor
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)).Patch
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)).Reserved
1319                 *p = read8(r)
1320         }
1321         var local49 []uint8
1322         var local50 uint16
1323         {
1324                 p := &local50
1325                 *p = read16(r)
1326         }
1327         (local49) = make([]uint8, local50)
1328         {
1329                 _, err := io.ReadFull(r, (local49)[:])
1330                 chk(err)
1331         }
1332         ((*(*(struct {
1333                 // Version information.
1334                 Major, Minor, Patch uint8
1335                 Reserved            uint8
1336                 Version             string
1337                 Formspec            uint16
1338         }))(obj)).Version) = string(local49)
1339         {
1340                 p := &(*(*(struct {
1341                         // Version information.
1342                         Major, Minor, Patch uint8
1343                         Reserved            uint8
1344                         Version             string
1345                         Formspec            uint16
1346                 }))(obj)).Formspec
1347                 *p = read16(r)
1348         }
1349 }
1350
1351 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1352         if len(((*(*(struct {
1353                 Salt        []byte
1354                 Verifier    []byte
1355                 EmptyPasswd bool
1356         }))(obj)).Salt)) > math.MaxUint16 {
1357                 chk(ErrTooLong)
1358         }
1359         {
1360                 x := uint16(len(((*(*(struct {
1361                         Salt        []byte
1362                         Verifier    []byte
1363                         EmptyPasswd bool
1364                 }))(obj)).Salt)))
1365                 write16(w, uint16(x))
1366         }
1367         {
1368                 _, err := w.Write(((*(*(struct {
1369                         Salt        []byte
1370                         Verifier    []byte
1371                         EmptyPasswd bool
1372                 }))(obj)).Salt)[:])
1373                 chk(err)
1374         }
1375         if len(((*(*(struct {
1376                 Salt        []byte
1377                 Verifier    []byte
1378                 EmptyPasswd bool
1379         }))(obj)).Verifier)) > math.MaxUint16 {
1380                 chk(ErrTooLong)
1381         }
1382         {
1383                 x := uint16(len(((*(*(struct {
1384                         Salt        []byte
1385                         Verifier    []byte
1386                         EmptyPasswd bool
1387                 }))(obj)).Verifier)))
1388                 write16(w, uint16(x))
1389         }
1390         {
1391                 _, err := w.Write(((*(*(struct {
1392                         Salt        []byte
1393                         Verifier    []byte
1394                         EmptyPasswd bool
1395                 }))(obj)).Verifier)[:])
1396                 chk(err)
1397         }
1398         {
1399                 x := (*(*(struct {
1400                         Salt        []byte
1401                         Verifier    []byte
1402                         EmptyPasswd bool
1403                 }))(obj)).EmptyPasswd
1404                 if x {
1405                         write8(w, 1)
1406                 } else {
1407                         write8(w, 0)
1408                 }
1409         }
1410 }
1411
1412 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1413         var local51 uint16
1414         {
1415                 p := &local51
1416                 *p = read16(r)
1417         }
1418         ((*(*(struct {
1419                 Salt        []byte
1420                 Verifier    []byte
1421                 EmptyPasswd bool
1422         }))(obj)).Salt) = make([]byte, local51)
1423         {
1424                 _, err := io.ReadFull(r, ((*(*(struct {
1425                         Salt        []byte
1426                         Verifier    []byte
1427                         EmptyPasswd bool
1428                 }))(obj)).Salt)[:])
1429                 chk(err)
1430         }
1431         var local52 uint16
1432         {
1433                 p := &local52
1434                 *p = read16(r)
1435         }
1436         ((*(*(struct {
1437                 Salt        []byte
1438                 Verifier    []byte
1439                 EmptyPasswd bool
1440         }))(obj)).Verifier) = make([]byte, local52)
1441         {
1442                 _, err := io.ReadFull(r, ((*(*(struct {
1443                         Salt        []byte
1444                         Verifier    []byte
1445                         EmptyPasswd bool
1446                 }))(obj)).Verifier)[:])
1447                 chk(err)
1448         }
1449         {
1450                 p := &(*(*(struct {
1451                         Salt        []byte
1452                         Verifier    []byte
1453                         EmptyPasswd bool
1454                 }))(obj)).EmptyPasswd
1455                 switch n := read8(r); n {
1456                 case 0:
1457                         *p = false
1458                 case 1:
1459                         *p = true
1460                 default:
1461                         chk(fmt.Errorf("invalid bool: %d", n))
1462                 }
1463         }
1464 }
1465
1466 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1467         if len(((*(*(struct {
1468                 A      []byte
1469                 NoSHA1 bool
1470         }))(obj)).A)) > math.MaxUint16 {
1471                 chk(ErrTooLong)
1472         }
1473         {
1474                 x := uint16(len(((*(*(struct {
1475                         A      []byte
1476                         NoSHA1 bool
1477                 }))(obj)).A)))
1478                 write16(w, uint16(x))
1479         }
1480         {
1481                 _, err := w.Write(((*(*(struct {
1482                         A      []byte
1483                         NoSHA1 bool
1484                 }))(obj)).A)[:])
1485                 chk(err)
1486         }
1487         {
1488                 x := (*(*(struct {
1489                         A      []byte
1490                         NoSHA1 bool
1491                 }))(obj)).NoSHA1
1492                 if x {
1493                         write8(w, 1)
1494                 } else {
1495                         write8(w, 0)
1496                 }
1497         }
1498 }
1499
1500 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1501         var local53 uint16
1502         {
1503                 p := &local53
1504                 *p = read16(r)
1505         }
1506         ((*(*(struct {
1507                 A      []byte
1508                 NoSHA1 bool
1509         }))(obj)).A) = make([]byte, local53)
1510         {
1511                 _, err := io.ReadFull(r, ((*(*(struct {
1512                         A      []byte
1513                         NoSHA1 bool
1514                 }))(obj)).A)[:])
1515                 chk(err)
1516         }
1517         {
1518                 p := &(*(*(struct {
1519                         A      []byte
1520                         NoSHA1 bool
1521                 }))(obj)).NoSHA1
1522                 switch n := read8(r); n {
1523                 case 0:
1524                         *p = false
1525                 case 1:
1526                         *p = true
1527                 default:
1528                         chk(fmt.Errorf("invalid bool: %d", n))
1529                 }
1530         }
1531 }
1532
1533 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1534         if len(((*(*(struct {
1535                 M []byte
1536         }))(obj)).M)) > math.MaxUint16 {
1537                 chk(ErrTooLong)
1538         }
1539         {
1540                 x := uint16(len(((*(*(struct {
1541                         M []byte
1542                 }))(obj)).M)))
1543                 write16(w, uint16(x))
1544         }
1545         {
1546                 _, err := w.Write(((*(*(struct {
1547                         M []byte
1548                 }))(obj)).M)[:])
1549                 chk(err)
1550         }
1551 }
1552
1553 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1554         var local54 uint16
1555         {
1556                 p := &local54
1557                 *p = read16(r)
1558         }
1559         ((*(*(struct {
1560                 M []byte
1561         }))(obj)).M) = make([]byte, local54)
1562         {
1563                 _, err := io.ReadFull(r, ((*(*(struct {
1564                         M []byte
1565                 }))(obj)).M)[:])
1566                 chk(err)
1567         }
1568 }
1569
1570 func (obj *ToCltHello) serialize(w io.Writer) {
1571         {
1572                 x := (*(*(struct {
1573                         SerializeVer uint8
1574                         Compression  CompressionModes
1575                         ProtoVer     uint16
1576                         AuthMethods
1577                         Username string
1578                 }))(obj)).SerializeVer
1579                 write8(w, uint8(x))
1580         }
1581         if err := pcall(func() {
1582                 ((*(*(struct {
1583                         SerializeVer uint8
1584                         Compression  CompressionModes
1585                         ProtoVer     uint16
1586                         AuthMethods
1587                         Username string
1588                 }))(obj)).Compression).serialize(w)
1589         }); err != nil {
1590                 if err == io.EOF {
1591                         chk(io.EOF)
1592                 }
1593                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
1594         }
1595         {
1596                 x := (*(*(struct {
1597                         SerializeVer uint8
1598                         Compression  CompressionModes
1599                         ProtoVer     uint16
1600                         AuthMethods
1601                         Username string
1602                 }))(obj)).ProtoVer
1603                 write16(w, uint16(x))
1604         }
1605         if err := pcall(func() {
1606                 ((*(*(struct {
1607                         SerializeVer uint8
1608                         Compression  CompressionModes
1609                         ProtoVer     uint16
1610                         AuthMethods
1611                         Username string
1612                 }))(obj)).AuthMethods).serialize(w)
1613         }); err != nil {
1614                 if err == io.EOF {
1615                         chk(io.EOF)
1616                 }
1617                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1618         }
1619         if len(([]byte((*(*(struct {
1620                 SerializeVer uint8
1621                 Compression  CompressionModes
1622                 ProtoVer     uint16
1623                 AuthMethods
1624                 Username string
1625         }))(obj)).Username))) > math.MaxUint16 {
1626                 chk(ErrTooLong)
1627         }
1628         {
1629                 x := uint16(len(([]byte((*(*(struct {
1630                         SerializeVer uint8
1631                         Compression  CompressionModes
1632                         ProtoVer     uint16
1633                         AuthMethods
1634                         Username string
1635                 }))(obj)).Username))))
1636                 write16(w, uint16(x))
1637         }
1638         {
1639                 _, err := w.Write(([]byte((*(*(struct {
1640                         SerializeVer uint8
1641                         Compression  CompressionModes
1642                         ProtoVer     uint16
1643                         AuthMethods
1644                         Username string
1645                 }))(obj)).Username))[:])
1646                 chk(err)
1647         }
1648 }
1649
1650 func (obj *ToCltHello) deserialize(r io.Reader) {
1651         {
1652                 p := &(*(*(struct {
1653                         SerializeVer uint8
1654                         Compression  CompressionModes
1655                         ProtoVer     uint16
1656                         AuthMethods
1657                         Username string
1658                 }))(obj)).SerializeVer
1659                 *p = read8(r)
1660         }
1661         if err := pcall(func() {
1662                 ((*(*(struct {
1663                         SerializeVer uint8
1664                         Compression  CompressionModes
1665                         ProtoVer     uint16
1666                         AuthMethods
1667                         Username string
1668                 }))(obj)).Compression).deserialize(r)
1669         }); err != nil {
1670                 if err == io.EOF {
1671                         chk(io.EOF)
1672                 }
1673                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
1674         }
1675         {
1676                 p := &(*(*(struct {
1677                         SerializeVer uint8
1678                         Compression  CompressionModes
1679                         ProtoVer     uint16
1680                         AuthMethods
1681                         Username string
1682                 }))(obj)).ProtoVer
1683                 *p = read16(r)
1684         }
1685         if err := pcall(func() {
1686                 ((*(*(struct {
1687                         SerializeVer uint8
1688                         Compression  CompressionModes
1689                         ProtoVer     uint16
1690                         AuthMethods
1691                         Username string
1692                 }))(obj)).AuthMethods).deserialize(r)
1693         }); err != nil {
1694                 if err == io.EOF {
1695                         chk(io.EOF)
1696                 }
1697                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1698         }
1699         var local55 []uint8
1700         var local56 uint16
1701         {
1702                 p := &local56
1703                 *p = read16(r)
1704         }
1705         (local55) = make([]uint8, local56)
1706         {
1707                 _, err := io.ReadFull(r, (local55)[:])
1708                 chk(err)
1709         }
1710         ((*(*(struct {
1711                 SerializeVer uint8
1712                 Compression  CompressionModes
1713                 ProtoVer     uint16
1714                 AuthMethods
1715                 Username string
1716         }))(obj)).Username) = string(local55)
1717 }
1718
1719 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1720         if err := pcall(func() {
1721                 ((*(*(struct {
1722                         // The client does the equivalent of
1723                         //      PlayerPos[1] -= 5
1724                         // before using PlayerPos.
1725                         PlayerPos Pos
1726
1727                         MapSeed         uint64
1728                         SendInterval    float32
1729                         SudoAuthMethods AuthMethods
1730                 }))(obj)).PlayerPos).serialize(w)
1731         }); err != nil {
1732                 if err == io.EOF {
1733                         chk(io.EOF)
1734                 }
1735                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
1736         }
1737         {
1738                 x := (*(*(struct {
1739                         // The client does the equivalent of
1740                         //      PlayerPos[1] -= 5
1741                         // before using PlayerPos.
1742                         PlayerPos Pos
1743
1744                         MapSeed         uint64
1745                         SendInterval    float32
1746                         SudoAuthMethods AuthMethods
1747                 }))(obj)).MapSeed
1748                 write64(w, uint64(x))
1749         }
1750         {
1751                 x := (*(*(struct {
1752                         // The client does the equivalent of
1753                         //      PlayerPos[1] -= 5
1754                         // before using PlayerPos.
1755                         PlayerPos Pos
1756
1757                         MapSeed         uint64
1758                         SendInterval    float32
1759                         SudoAuthMethods AuthMethods
1760                 }))(obj)).SendInterval
1761                 write32(w, math.Float32bits(x))
1762         }
1763         if err := pcall(func() {
1764                 ((*(*(struct {
1765                         // The client does the equivalent of
1766                         //      PlayerPos[1] -= 5
1767                         // before using PlayerPos.
1768                         PlayerPos Pos
1769
1770                         MapSeed         uint64
1771                         SendInterval    float32
1772                         SudoAuthMethods AuthMethods
1773                 }))(obj)).SudoAuthMethods).serialize(w)
1774         }); err != nil {
1775                 if err == io.EOF {
1776                         chk(io.EOF)
1777                 }
1778                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1779         }
1780 }
1781
1782 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1783         if err := pcall(func() {
1784                 ((*(*(struct {
1785                         // The client does the equivalent of
1786                         //      PlayerPos[1] -= 5
1787                         // before using PlayerPos.
1788                         PlayerPos Pos
1789
1790                         MapSeed         uint64
1791                         SendInterval    float32
1792                         SudoAuthMethods AuthMethods
1793                 }))(obj)).PlayerPos).deserialize(r)
1794         }); err != nil {
1795                 if err == io.EOF {
1796                         chk(io.EOF)
1797                 }
1798                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
1799         }
1800         {
1801                 p := &(*(*(struct {
1802                         // The client does the equivalent of
1803                         //      PlayerPos[1] -= 5
1804                         // before using PlayerPos.
1805                         PlayerPos Pos
1806
1807                         MapSeed         uint64
1808                         SendInterval    float32
1809                         SudoAuthMethods AuthMethods
1810                 }))(obj)).MapSeed
1811                 *p = read64(r)
1812         }
1813         {
1814                 p := &(*(*(struct {
1815                         // The client does the equivalent of
1816                         //      PlayerPos[1] -= 5
1817                         // before using PlayerPos.
1818                         PlayerPos Pos
1819
1820                         MapSeed         uint64
1821                         SendInterval    float32
1822                         SudoAuthMethods AuthMethods
1823                 }))(obj)).SendInterval
1824                 *p = math.Float32frombits(read32(r))
1825         }
1826         if err := pcall(func() {
1827                 ((*(*(struct {
1828                         // The client does the equivalent of
1829                         //      PlayerPos[1] -= 5
1830                         // before using PlayerPos.
1831                         PlayerPos Pos
1832
1833                         MapSeed         uint64
1834                         SendInterval    float32
1835                         SudoAuthMethods AuthMethods
1836                 }))(obj)).SudoAuthMethods).deserialize(r)
1837         }); err != nil {
1838                 if err == io.EOF {
1839                         chk(io.EOF)
1840                 }
1841                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1842         }
1843 }
1844
1845 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1846         if err := pcall(func() {
1847                 ((*(*(struct {
1848                         SudoAuthMethods AuthMethods
1849                 }))(obj)).SudoAuthMethods).serialize(w)
1850         }); err != nil {
1851                 if err == io.EOF {
1852                         chk(io.EOF)
1853                 }
1854                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1855         }
1856         {
1857                 local57 := [15]byte{}
1858                 {
1859                         _, err := w.Write((local57)[:])
1860                         chk(err)
1861                 }
1862         }
1863 }
1864
1865 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1866         if err := pcall(func() {
1867                 ((*(*(struct {
1868                         SudoAuthMethods AuthMethods
1869                 }))(obj)).SudoAuthMethods).deserialize(r)
1870         }); err != nil {
1871                 if err == io.EOF {
1872                         chk(io.EOF)
1873                 }
1874                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1875         }
1876         {
1877                 var local58 [15]byte
1878                 local59 := [15]byte{}
1879                 {
1880                         _, err := io.ReadFull(r, (local58)[:])
1881                         chk(err)
1882                 }
1883                 if local58 != local59 {
1884                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1885                 }
1886         }
1887 }
1888
1889 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1890 }
1891
1892 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1893 }
1894
1895 func (obj *ToCltKick) serialize(w io.Writer) {
1896         if err := pcall(func() {
1897                 ((*(*(struct {
1898                         Reason KickReason
1899
1900                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1901                         Custom string
1902
1903                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1904                         Reconnect bool
1905                 }))(obj)).Reason).serialize(w)
1906         }); err != nil {
1907                 if err == io.EOF {
1908                         chk(io.EOF)
1909                 }
1910                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.KickReason", err))
1911         }
1912         if !((*(*(struct {
1913                 Reason KickReason
1914
1915                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1916                 Custom string
1917
1918                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1919                 Reconnect bool
1920         }))(obj)).Reason < maxKickReason) {
1921                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1922         }
1923         if dr := (*(*(struct {
1924                 Reason KickReason
1925
1926                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1927                 Custom string
1928
1929                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1930                 Reconnect bool
1931         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1932                 if len(([]byte((*(*(struct {
1933                         Reason KickReason
1934
1935                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1936                         Custom string
1937
1938                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1939                         Reconnect bool
1940                 }))(obj)).Custom))) > math.MaxUint16 {
1941                         chk(ErrTooLong)
1942                 }
1943                 {
1944                         x := uint16(len(([]byte((*(*(struct {
1945                                 Reason KickReason
1946
1947                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1948                                 Custom string
1949
1950                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1951                                 Reconnect bool
1952                         }))(obj)).Custom))))
1953                         write16(w, uint16(x))
1954                 }
1955                 {
1956                         _, err := w.Write(([]byte((*(*(struct {
1957                                 Reason KickReason
1958
1959                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1960                                 Custom string
1961
1962                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1963                                 Reconnect bool
1964                         }))(obj)).Custom))[:])
1965                         chk(err)
1966                 }
1967         }
1968         if dr := (*(*(struct {
1969                 Reason KickReason
1970
1971                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1972                 Custom string
1973
1974                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1975                 Reconnect bool
1976         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1977                 {
1978                         x := (*(*(struct {
1979                                 Reason KickReason
1980
1981                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1982                                 Custom string
1983
1984                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1985                                 Reconnect bool
1986                         }))(obj)).Reconnect
1987                         if x {
1988                                 write8(w, 1)
1989                         } else {
1990                                 write8(w, 0)
1991                         }
1992                 }
1993         }
1994 }
1995
1996 func (obj *ToCltKick) deserialize(r io.Reader) {
1997         if err := pcall(func() {
1998                 ((*(*(struct {
1999                         Reason KickReason
2000
2001                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2002                         Custom string
2003
2004                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2005                         Reconnect bool
2006                 }))(obj)).Reason).deserialize(r)
2007         }); err != nil {
2008                 if err == io.EOF {
2009                         chk(io.EOF)
2010                 }
2011                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.KickReason", err))
2012         }
2013         if !((*(*(struct {
2014                 Reason KickReason
2015
2016                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2017                 Custom string
2018
2019                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2020                 Reconnect bool
2021         }))(obj)).Reason < maxKickReason) {
2022                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2023         }
2024         if dr := (*(*(struct {
2025                 Reason KickReason
2026
2027                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2028                 Custom string
2029
2030                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2031                 Reconnect bool
2032         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2033                 var local60 []uint8
2034                 var local61 uint16
2035                 {
2036                         p := &local61
2037                         *p = read16(r)
2038                 }
2039                 (local60) = make([]uint8, local61)
2040                 {
2041                         _, err := io.ReadFull(r, (local60)[:])
2042                         chk(err)
2043                 }
2044                 ((*(*(struct {
2045                         Reason KickReason
2046
2047                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2048                         Custom string
2049
2050                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2051                         Reconnect bool
2052                 }))(obj)).Custom) = string(local60)
2053         }
2054         if dr := (*(*(struct {
2055                 Reason KickReason
2056
2057                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2058                 Custom string
2059
2060                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2061                 Reconnect bool
2062         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2063                 {
2064                         p := &(*(*(struct {
2065                                 Reason KickReason
2066
2067                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2068                                 Custom string
2069
2070                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2071                                 Reconnect bool
2072                         }))(obj)).Reconnect
2073                         switch n := read8(r); n {
2074                         case 0:
2075                                 *p = false
2076                         case 1:
2077                                 *p = true
2078                         default:
2079                                 chk(fmt.Errorf("invalid bool: %d", n))
2080                         }
2081                 }
2082         }
2083 }
2084
2085 func (obj *ToCltBlkData) serialize(w io.Writer) {
2086         for local62 := range (*(*(struct {
2087                 Blkpos [3]int16
2088                 Blk    MapBlk
2089         }))(obj)).Blkpos {
2090                 {
2091                         x := ((*(*(struct {
2092                                 Blkpos [3]int16
2093                                 Blk    MapBlk
2094                         }))(obj)).Blkpos)[local62]
2095                         write16(w, uint16(x))
2096                 }
2097         }
2098         if err := pcall(func() {
2099                 ((*(*(struct {
2100                         Blkpos [3]int16
2101                         Blk    MapBlk
2102                 }))(obj)).Blk).serialize(w)
2103         }); err != nil {
2104                 if err == io.EOF {
2105                         chk(io.EOF)
2106                 }
2107                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlk", err))
2108         }
2109 }
2110
2111 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2112         for local63 := range (*(*(struct {
2113                 Blkpos [3]int16
2114                 Blk    MapBlk
2115         }))(obj)).Blkpos {
2116                 {
2117                         p := &((*(*(struct {
2118                                 Blkpos [3]int16
2119                                 Blk    MapBlk
2120                         }))(obj)).Blkpos)[local63]
2121                         *p = int16(read16(r))
2122                 }
2123         }
2124         if err := pcall(func() {
2125                 ((*(*(struct {
2126                         Blkpos [3]int16
2127                         Blk    MapBlk
2128                 }))(obj)).Blk).deserialize(r)
2129         }); err != nil {
2130                 if err == io.EOF {
2131                         chk(io.EOF)
2132                 }
2133                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlk", err))
2134         }
2135 }
2136
2137 func (obj *ToCltAddNode) serialize(w io.Writer) {
2138         for local64 := range (*(*(struct {
2139                 Pos [3]int16
2140                 Node
2141                 KeepMeta bool
2142         }))(obj)).Pos {
2143                 {
2144                         x := ((*(*(struct {
2145                                 Pos [3]int16
2146                                 Node
2147                                 KeepMeta bool
2148                         }))(obj)).Pos)[local64]
2149                         write16(w, uint16(x))
2150                 }
2151         }
2152         if err := pcall(func() {
2153                 ((*(*(struct {
2154                         Pos [3]int16
2155                         Node
2156                         KeepMeta bool
2157                 }))(obj)).Node).serialize(w)
2158         }); err != nil {
2159                 if err == io.EOF {
2160                         chk(io.EOF)
2161                 }
2162                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Node", err))
2163         }
2164         {
2165                 x := (*(*(struct {
2166                         Pos [3]int16
2167                         Node
2168                         KeepMeta bool
2169                 }))(obj)).KeepMeta
2170                 if x {
2171                         write8(w, 1)
2172                 } else {
2173                         write8(w, 0)
2174                 }
2175         }
2176 }
2177
2178 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2179         for local65 := range (*(*(struct {
2180                 Pos [3]int16
2181                 Node
2182                 KeepMeta bool
2183         }))(obj)).Pos {
2184                 {
2185                         p := &((*(*(struct {
2186                                 Pos [3]int16
2187                                 Node
2188                                 KeepMeta bool
2189                         }))(obj)).Pos)[local65]
2190                         *p = int16(read16(r))
2191                 }
2192         }
2193         if err := pcall(func() {
2194                 ((*(*(struct {
2195                         Pos [3]int16
2196                         Node
2197                         KeepMeta bool
2198                 }))(obj)).Node).deserialize(r)
2199         }); err != nil {
2200                 if err == io.EOF {
2201                         chk(io.EOF)
2202                 }
2203                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Node", err))
2204         }
2205         {
2206                 p := &(*(*(struct {
2207                         Pos [3]int16
2208                         Node
2209                         KeepMeta bool
2210                 }))(obj)).KeepMeta
2211                 switch n := read8(r); n {
2212                 case 0:
2213                         *p = false
2214                 case 1:
2215                         *p = true
2216                 default:
2217                         chk(fmt.Errorf("invalid bool: %d", n))
2218                 }
2219         }
2220 }
2221
2222 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2223         for local66 := range (*(*(struct {
2224                 Pos [3]int16
2225         }))(obj)).Pos {
2226                 {
2227                         x := ((*(*(struct {
2228                                 Pos [3]int16
2229                         }))(obj)).Pos)[local66]
2230                         write16(w, uint16(x))
2231                 }
2232         }
2233 }
2234
2235 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2236         for local67 := range (*(*(struct {
2237                 Pos [3]int16
2238         }))(obj)).Pos {
2239                 {
2240                         p := &((*(*(struct {
2241                                 Pos [3]int16
2242                         }))(obj)).Pos)[local67]
2243                         *p = int16(read16(r))
2244                 }
2245         }
2246 }
2247
2248 func (obj *ToCltInv) serialize(w io.Writer) {
2249         {
2250                 _, err := w.Write(([]byte((*(*(struct {
2251                         //mt:raw
2252                         Inv string
2253                 }))(obj)).Inv))[:])
2254                 chk(err)
2255         }
2256 }
2257
2258 func (obj *ToCltInv) deserialize(r io.Reader) {
2259         var local68 []uint8
2260         {
2261                 var err error
2262                 (local68), err = io.ReadAll(r)
2263                 chk(err)
2264         }
2265         ((*(*(struct {
2266                 //mt:raw
2267                 Inv string
2268         }))(obj)).Inv) = string(local68)
2269 }
2270
2271 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2272         {
2273                 x := (*(*(struct {
2274                         Time  uint16  // %24000
2275                         Speed float32 // Speed times faster than real time
2276                 }))(obj)).Time
2277                 write16(w, uint16(x))
2278         }
2279         {
2280                 x := (*(*(struct {
2281                         Time  uint16  // %24000
2282                         Speed float32 // Speed times faster than real time
2283                 }))(obj)).Speed
2284                 write32(w, math.Float32bits(x))
2285         }
2286 }
2287
2288 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2289         {
2290                 p := &(*(*(struct {
2291                         Time  uint16  // %24000
2292                         Speed float32 // Speed times faster than real time
2293                 }))(obj)).Time
2294                 *p = read16(r)
2295         }
2296         {
2297                 p := &(*(*(struct {
2298                         Time  uint16  // %24000
2299                         Speed float32 // Speed times faster than real time
2300                 }))(obj)).Speed
2301                 *p = math.Float32frombits(read32(r))
2302         }
2303 }
2304
2305 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2306         if err := pcall(func() {
2307                 ((*(*(struct {
2308                         Flags CSMRestrictionFlags
2309
2310                         // MapRange is the maximum distance from the player CSMs can read the map
2311                         // if Flags&LimitMapRange != 0.
2312                         MapRange uint32
2313                 }))(obj)).Flags).serialize(w)
2314         }); err != nil {
2315                 if err == io.EOF {
2316                         chk(io.EOF)
2317                 }
2318                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CSMRestrictionFlags", err))
2319         }
2320         {
2321                 x := (*(*(struct {
2322                         Flags CSMRestrictionFlags
2323
2324                         // MapRange is the maximum distance from the player CSMs can read the map
2325                         // if Flags&LimitMapRange != 0.
2326                         MapRange uint32
2327                 }))(obj)).MapRange
2328                 write32(w, uint32(x))
2329         }
2330 }
2331
2332 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2333         if err := pcall(func() {
2334                 ((*(*(struct {
2335                         Flags CSMRestrictionFlags
2336
2337                         // MapRange is the maximum distance from the player CSMs can read the map
2338                         // if Flags&LimitMapRange != 0.
2339                         MapRange uint32
2340                 }))(obj)).Flags).deserialize(r)
2341         }); err != nil {
2342                 if err == io.EOF {
2343                         chk(io.EOF)
2344                 }
2345                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CSMRestrictionFlags", err))
2346         }
2347         {
2348                 p := &(*(*(struct {
2349                         Flags CSMRestrictionFlags
2350
2351                         // MapRange is the maximum distance from the player CSMs can read the map
2352                         // if Flags&LimitMapRange != 0.
2353                         MapRange uint32
2354                 }))(obj)).MapRange
2355                 *p = read32(r)
2356         }
2357 }
2358
2359 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2360         if err := pcall(func() {
2361                 ((*(*(struct {
2362                         Vel Vec
2363                 }))(obj)).Vel).serialize(w)
2364         }); err != nil {
2365                 if err == io.EOF {
2366                         chk(io.EOF)
2367                 }
2368                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
2369         }
2370 }
2371
2372 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2373         if err := pcall(func() {
2374                 ((*(*(struct {
2375                         Vel Vec
2376                 }))(obj)).Vel).deserialize(r)
2377         }); err != nil {
2378                 if err == io.EOF {
2379                         chk(io.EOF)
2380                 }
2381                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
2382         }
2383 }
2384
2385 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2386         if len(([]byte((*(*(struct {
2387                 RawHash       string
2388                 Filename      string
2389                 CallbackToken uint32
2390                 ShouldCache   bool
2391         }))(obj)).RawHash))) > math.MaxUint16 {
2392                 chk(ErrTooLong)
2393         }
2394         {
2395                 x := uint16(len(([]byte((*(*(struct {
2396                         RawHash       string
2397                         Filename      string
2398                         CallbackToken uint32
2399                         ShouldCache   bool
2400                 }))(obj)).RawHash))))
2401                 write16(w, uint16(x))
2402         }
2403         {
2404                 _, err := w.Write(([]byte((*(*(struct {
2405                         RawHash       string
2406                         Filename      string
2407                         CallbackToken uint32
2408                         ShouldCache   bool
2409                 }))(obj)).RawHash))[:])
2410                 chk(err)
2411         }
2412         if len(([]byte((*(*(struct {
2413                 RawHash       string
2414                 Filename      string
2415                 CallbackToken uint32
2416                 ShouldCache   bool
2417         }))(obj)).Filename))) > math.MaxUint16 {
2418                 chk(ErrTooLong)
2419         }
2420         {
2421                 x := uint16(len(([]byte((*(*(struct {
2422                         RawHash       string
2423                         Filename      string
2424                         CallbackToken uint32
2425                         ShouldCache   bool
2426                 }))(obj)).Filename))))
2427                 write16(w, uint16(x))
2428         }
2429         {
2430                 _, err := w.Write(([]byte((*(*(struct {
2431                         RawHash       string
2432                         Filename      string
2433                         CallbackToken uint32
2434                         ShouldCache   bool
2435                 }))(obj)).Filename))[:])
2436                 chk(err)
2437         }
2438         {
2439                 x := (*(*(struct {
2440                         RawHash       string
2441                         Filename      string
2442                         CallbackToken uint32
2443                         ShouldCache   bool
2444                 }))(obj)).CallbackToken
2445                 write32(w, uint32(x))
2446         }
2447         {
2448                 x := (*(*(struct {
2449                         RawHash       string
2450                         Filename      string
2451                         CallbackToken uint32
2452                         ShouldCache   bool
2453                 }))(obj)).ShouldCache
2454                 if x {
2455                         write8(w, 1)
2456                 } else {
2457                         write8(w, 0)
2458                 }
2459         }
2460 }
2461
2462 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2463         var local69 []uint8
2464         var local70 uint16
2465         {
2466                 p := &local70
2467                 *p = read16(r)
2468         }
2469         (local69) = make([]uint8, local70)
2470         {
2471                 _, err := io.ReadFull(r, (local69)[:])
2472                 chk(err)
2473         }
2474         ((*(*(struct {
2475                 RawHash       string
2476                 Filename      string
2477                 CallbackToken uint32
2478                 ShouldCache   bool
2479         }))(obj)).RawHash) = string(local69)
2480         var local71 []uint8
2481         var local72 uint16
2482         {
2483                 p := &local72
2484                 *p = read16(r)
2485         }
2486         (local71) = make([]uint8, local72)
2487         {
2488                 _, err := io.ReadFull(r, (local71)[:])
2489                 chk(err)
2490         }
2491         ((*(*(struct {
2492                 RawHash       string
2493                 Filename      string
2494                 CallbackToken uint32
2495                 ShouldCache   bool
2496         }))(obj)).Filename) = string(local71)
2497         {
2498                 p := &(*(*(struct {
2499                         RawHash       string
2500                         Filename      string
2501                         CallbackToken uint32
2502                         ShouldCache   bool
2503                 }))(obj)).CallbackToken
2504                 *p = read32(r)
2505         }
2506         {
2507                 p := &(*(*(struct {
2508                         RawHash       string
2509                         Filename      string
2510                         CallbackToken uint32
2511                         ShouldCache   bool
2512                 }))(obj)).ShouldCache
2513                 switch n := read8(r); n {
2514                 case 0:
2515                         *p = false
2516                 case 1:
2517                         *p = true
2518                 default:
2519                         chk(fmt.Errorf("invalid bool: %d", n))
2520                 }
2521         }
2522 }
2523
2524 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2525         {
2526                 local73 := uint8(1)
2527                 {
2528                         x := local73
2529                         write8(w, uint8(x))
2530                 }
2531         }
2532         if err := pcall(func() {
2533                 ((*(*(struct {
2534                         Type ChatMsgType
2535
2536                         //mt:utf16
2537                         Sender, Text string
2538
2539                         Timestamp int64 // Unix time.
2540                 }))(obj)).Type).serialize(w)
2541         }); err != nil {
2542                 if err == io.EOF {
2543                         chk(io.EOF)
2544                 }
2545                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ChatMsgType", err))
2546         }
2547         local74 := utf16.Encode([]rune((*(*(struct {
2548                 Type ChatMsgType
2549
2550                 //mt:utf16
2551                 Sender, Text string
2552
2553                 Timestamp int64 // Unix time.
2554         }))(obj)).Sender))
2555         if len((local74)) > math.MaxUint16 {
2556                 chk(ErrTooLong)
2557         }
2558         {
2559                 x := uint16(len((local74)))
2560                 write16(w, uint16(x))
2561         }
2562         for local75 := range local74 {
2563                 {
2564                         x := (local74)[local75]
2565                         write16(w, uint16(x))
2566                 }
2567         }
2568         local76 := utf16.Encode([]rune((*(*(struct {
2569                 Type ChatMsgType
2570
2571                 //mt:utf16
2572                 Sender, Text string
2573
2574                 Timestamp int64 // Unix time.
2575         }))(obj)).Text))
2576         if len((local76)) > math.MaxUint16 {
2577                 chk(ErrTooLong)
2578         }
2579         {
2580                 x := uint16(len((local76)))
2581                 write16(w, uint16(x))
2582         }
2583         for local77 := range local76 {
2584                 {
2585                         x := (local76)[local77]
2586                         write16(w, uint16(x))
2587                 }
2588         }
2589         {
2590                 x := (*(*(struct {
2591                         Type ChatMsgType
2592
2593                         //mt:utf16
2594                         Sender, Text string
2595
2596                         Timestamp int64 // Unix time.
2597                 }))(obj)).Timestamp
2598                 write64(w, uint64(x))
2599         }
2600 }
2601
2602 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2603         {
2604                 var local78 uint8
2605                 local79 := uint8(1)
2606                 {
2607                         p := &local78
2608                         *p = read8(r)
2609                 }
2610                 if local78 != local79 {
2611                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local78))
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).deserialize(r)
2623         }); err != nil {
2624                 if err == io.EOF {
2625                         chk(io.EOF)
2626                 }
2627                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ChatMsgType", err))
2628         }
2629         var local80 []uint16
2630         var local81 uint16
2631         {
2632                 p := &local81
2633                 *p = read16(r)
2634         }
2635         (local80) = make([]uint16, local81)
2636         for local82 := range local80 {
2637                 {
2638                         p := &(local80)[local82]
2639                         *p = read16(r)
2640                 }
2641         }
2642         (*(*(struct {
2643                 Type ChatMsgType
2644
2645                 //mt:utf16
2646                 Sender, Text string
2647
2648                 Timestamp int64 // Unix time.
2649         }))(obj)).Sender = string(utf16.Decode(local80))
2650         var local83 []uint16
2651         var local84 uint16
2652         {
2653                 p := &local84
2654                 *p = read16(r)
2655         }
2656         (local83) = make([]uint16, local84)
2657         for local85 := range local83 {
2658                 {
2659                         p := &(local83)[local85]
2660                         *p = read16(r)
2661                 }
2662         }
2663         (*(*(struct {
2664                 Type ChatMsgType
2665
2666                 //mt:utf16
2667                 Sender, Text string
2668
2669                 Timestamp int64 // Unix time.
2670         }))(obj)).Text = string(utf16.Decode(local83))
2671         {
2672                 p := &(*(*(struct {
2673                         Type ChatMsgType
2674
2675                         //mt:utf16
2676                         Sender, Text string
2677
2678                         Timestamp int64 // Unix time.
2679                 }))(obj)).Timestamp
2680                 *p = int64(read64(r))
2681         }
2682 }
2683
2684 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2685         if len(((*(*(struct {
2686                 Remove []AOID
2687                 Add    []AOAdd
2688         }))(obj)).Remove)) > math.MaxUint16 {
2689                 chk(ErrTooLong)
2690         }
2691         {
2692                 x := uint16(len(((*(*(struct {
2693                         Remove []AOID
2694                         Add    []AOAdd
2695                 }))(obj)).Remove)))
2696                 write16(w, uint16(x))
2697         }
2698         for local86 := range (*(*(struct {
2699                 Remove []AOID
2700                 Add    []AOAdd
2701         }))(obj)).Remove {
2702                 if err := pcall(func() {
2703                         (((*(*(struct {
2704                                 Remove []AOID
2705                                 Add    []AOAdd
2706                         }))(obj)).Remove)[local86]).serialize(w)
2707                 }); err != nil {
2708                         if err == io.EOF {
2709                                 chk(io.EOF)
2710                         }
2711                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
2712                 }
2713         }
2714         if len(((*(*(struct {
2715                 Remove []AOID
2716                 Add    []AOAdd
2717         }))(obj)).Add)) > math.MaxUint16 {
2718                 chk(ErrTooLong)
2719         }
2720         {
2721                 x := uint16(len(((*(*(struct {
2722                         Remove []AOID
2723                         Add    []AOAdd
2724                 }))(obj)).Add)))
2725                 write16(w, uint16(x))
2726         }
2727         for local87 := range (*(*(struct {
2728                 Remove []AOID
2729                 Add    []AOAdd
2730         }))(obj)).Add {
2731                 if err := pcall(func() {
2732                         (((*(*(struct {
2733                                 Remove []AOID
2734                                 Add    []AOAdd
2735                         }))(obj)).Add)[local87]).serialize(w)
2736                 }); err != nil {
2737                         if err == io.EOF {
2738                                 chk(io.EOF)
2739                         }
2740                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAdd", err))
2741                 }
2742         }
2743 }
2744
2745 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2746         var local88 uint16
2747         {
2748                 p := &local88
2749                 *p = read16(r)
2750         }
2751         ((*(*(struct {
2752                 Remove []AOID
2753                 Add    []AOAdd
2754         }))(obj)).Remove) = make([]AOID, local88)
2755         for local89 := range (*(*(struct {
2756                 Remove []AOID
2757                 Add    []AOAdd
2758         }))(obj)).Remove {
2759                 if err := pcall(func() {
2760                         (((*(*(struct {
2761                                 Remove []AOID
2762                                 Add    []AOAdd
2763                         }))(obj)).Remove)[local89]).deserialize(r)
2764                 }); err != nil {
2765                         if err == io.EOF {
2766                                 chk(io.EOF)
2767                         }
2768                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
2769                 }
2770         }
2771         var local90 uint16
2772         {
2773                 p := &local90
2774                 *p = read16(r)
2775         }
2776         ((*(*(struct {
2777                 Remove []AOID
2778                 Add    []AOAdd
2779         }))(obj)).Add) = make([]AOAdd, local90)
2780         for local91 := range (*(*(struct {
2781                 Remove []AOID
2782                 Add    []AOAdd
2783         }))(obj)).Add {
2784                 if err := pcall(func() {
2785                         (((*(*(struct {
2786                                 Remove []AOID
2787                                 Add    []AOAdd
2788                         }))(obj)).Add)[local91]).deserialize(r)
2789                 }); err != nil {
2790                         if err == io.EOF {
2791                                 chk(io.EOF)
2792                         }
2793                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAdd", err))
2794                 }
2795         }
2796 }
2797
2798 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2799         for local92 := range (*(*(struct {
2800                 //mt:raw
2801                 Msgs []IDAOMsg
2802         }))(obj)).Msgs {
2803                 if err := pcall(func() {
2804                         (((*(*(struct {
2805                                 //mt:raw
2806                                 Msgs []IDAOMsg
2807                         }))(obj)).Msgs)[local92]).serialize(w)
2808                 }); err != nil {
2809                         if err == io.EOF {
2810                                 chk(io.EOF)
2811                         }
2812                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.IDAOMsg", err))
2813                 }
2814         }
2815 }
2816
2817 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2818         for {
2819                 var local93 IDAOMsg
2820                 err := pcall(func() {
2821                         if err := pcall(func() {
2822                                 (local93).deserialize(r)
2823                         }); err != nil {
2824                                 if err == io.EOF {
2825                                         chk(io.EOF)
2826                                 }
2827                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.IDAOMsg", err))
2828                         }
2829                 })
2830                 if err == io.EOF {
2831                         break
2832                 }
2833                 ((*(*(struct {
2834                         //mt:raw
2835                         Msgs []IDAOMsg
2836                 }))(obj)).Msgs) = append(((*(*(struct {
2837                         //mt:raw
2838                         Msgs []IDAOMsg
2839                 }))(obj)).Msgs), local93)
2840                 chk(err)
2841         }
2842 }
2843
2844 func (obj *ToCltHP) serialize(w io.Writer) {
2845         {
2846                 x := (*(*(struct {
2847                         HP uint16
2848                 }))(obj)).HP
2849                 write16(w, uint16(x))
2850         }
2851 }
2852
2853 func (obj *ToCltHP) deserialize(r io.Reader) {
2854         {
2855                 p := &(*(*(struct {
2856                         HP uint16
2857                 }))(obj)).HP
2858                 *p = read16(r)
2859         }
2860 }
2861
2862 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2863         if err := pcall(func() {
2864                 ((*(*(struct {
2865                         Pos
2866                         Pitch, Yaw float32
2867                 }))(obj)).Pos).serialize(w)
2868         }); err != nil {
2869                 if err == io.EOF {
2870                         chk(io.EOF)
2871                 }
2872                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
2873         }
2874         {
2875                 x := (*(*(struct {
2876                         Pos
2877                         Pitch, Yaw float32
2878                 }))(obj)).Pitch
2879                 write32(w, math.Float32bits(x))
2880         }
2881         {
2882                 x := (*(*(struct {
2883                         Pos
2884                         Pitch, Yaw float32
2885                 }))(obj)).Yaw
2886                 write32(w, math.Float32bits(x))
2887         }
2888 }
2889
2890 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2891         if err := pcall(func() {
2892                 ((*(*(struct {
2893                         Pos
2894                         Pitch, Yaw float32
2895                 }))(obj)).Pos).deserialize(r)
2896         }); err != nil {
2897                 if err == io.EOF {
2898                         chk(io.EOF)
2899                 }
2900                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
2901         }
2902         {
2903                 p := &(*(*(struct {
2904                         Pos
2905                         Pitch, Yaw float32
2906                 }))(obj)).Pitch
2907                 *p = math.Float32frombits(read32(r))
2908         }
2909         {
2910                 p := &(*(*(struct {
2911                         Pos
2912                         Pitch, Yaw float32
2913                 }))(obj)).Yaw
2914                 *p = math.Float32frombits(read32(r))
2915         }
2916 }
2917
2918 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
2919         local94 := utf16.Encode([]rune((*(*(struct {
2920                 //mt:utf16
2921                 Reason string
2922         }))(obj)).Reason))
2923         if len((local94)) > math.MaxUint16 {
2924                 chk(ErrTooLong)
2925         }
2926         {
2927                 x := uint16(len((local94)))
2928                 write16(w, uint16(x))
2929         }
2930         for local95 := range local94 {
2931                 {
2932                         x := (local94)[local95]
2933                         write16(w, uint16(x))
2934                 }
2935         }
2936 }
2937
2938 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
2939         var local96 []uint16
2940         var local97 uint16
2941         {
2942                 p := &local97
2943                 *p = read16(r)
2944         }
2945         (local96) = make([]uint16, local97)
2946         for local98 := range local96 {
2947                 {
2948                         p := &(local96)[local98]
2949                         *p = read16(r)
2950                 }
2951         }
2952         (*(*(struct {
2953                 //mt:utf16
2954                 Reason string
2955         }))(obj)).Reason = string(utf16.Decode(local96))
2956 }
2957
2958 func (obj *ToCltFOV) serialize(w io.Writer) {
2959         {
2960                 x := (*(*(struct {
2961                         FOV            float32
2962                         Multiplier     bool
2963                         TransitionTime float32
2964                 }))(obj)).FOV
2965                 write32(w, math.Float32bits(x))
2966         }
2967         {
2968                 x := (*(*(struct {
2969                         FOV            float32
2970                         Multiplier     bool
2971                         TransitionTime float32
2972                 }))(obj)).Multiplier
2973                 if x {
2974                         write8(w, 1)
2975                 } else {
2976                         write8(w, 0)
2977                 }
2978         }
2979         {
2980                 x := (*(*(struct {
2981                         FOV            float32
2982                         Multiplier     bool
2983                         TransitionTime float32
2984                 }))(obj)).TransitionTime
2985                 write32(w, math.Float32bits(x))
2986         }
2987 }
2988
2989 func (obj *ToCltFOV) deserialize(r io.Reader) {
2990         {
2991                 p := &(*(*(struct {
2992                         FOV            float32
2993                         Multiplier     bool
2994                         TransitionTime float32
2995                 }))(obj)).FOV
2996                 *p = math.Float32frombits(read32(r))
2997         }
2998         {
2999                 p := &(*(*(struct {
3000                         FOV            float32
3001                         Multiplier     bool
3002                         TransitionTime float32
3003                 }))(obj)).Multiplier
3004                 switch n := read8(r); n {
3005                 case 0:
3006                         *p = false
3007                 case 1:
3008                         *p = true
3009                 default:
3010                         chk(fmt.Errorf("invalid bool: %d", n))
3011                 }
3012         }
3013         {
3014                 p := &(*(*(struct {
3015                         FOV            float32
3016                         Multiplier     bool
3017                         TransitionTime float32
3018                 }))(obj)).TransitionTime
3019                 *p = math.Float32frombits(read32(r))
3020         }
3021 }
3022
3023 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3024         {
3025                 x := (*(*(struct {
3026                         PointCam bool
3027                         PointAt  Pos
3028                 }))(obj)).PointCam
3029                 if x {
3030                         write8(w, 1)
3031                 } else {
3032                         write8(w, 0)
3033                 }
3034         }
3035         if err := pcall(func() {
3036                 ((*(*(struct {
3037                         PointCam bool
3038                         PointAt  Pos
3039                 }))(obj)).PointAt).serialize(w)
3040         }); err != nil {
3041                 if err == io.EOF {
3042                         chk(io.EOF)
3043                 }
3044                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
3045         }
3046 }
3047
3048 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3049         {
3050                 p := &(*(*(struct {
3051                         PointCam bool
3052                         PointAt  Pos
3053                 }))(obj)).PointCam
3054                 switch n := read8(r); n {
3055                 case 0:
3056                         *p = false
3057                 case 1:
3058                         *p = true
3059                 default:
3060                         chk(fmt.Errorf("invalid bool: %d", n))
3061                 }
3062         }
3063         if err := pcall(func() {
3064                 ((*(*(struct {
3065                         PointCam bool
3066                         PointAt  Pos
3067                 }))(obj)).PointAt).deserialize(r)
3068         }); err != nil {
3069                 if err == io.EOF {
3070                         chk(io.EOF)
3071                 }
3072                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
3073         }
3074 }
3075
3076 func (obj *ToCltMedia) serialize(w io.Writer) {
3077         {
3078                 x := (*(*(struct {
3079                         // N is the total number of ToCltMedia packets.
3080                         // I is the index of this packet.
3081                         N, I uint16
3082
3083                         //mt:len32
3084                         Files []struct {
3085                                 Name string
3086
3087                                 //mt:len32
3088                                 Data []byte
3089                         }
3090                 }))(obj)).N
3091                 write16(w, uint16(x))
3092         }
3093         {
3094                 x := (*(*(struct {
3095                         // N is the total number of ToCltMedia packets.
3096                         // I is the index of this packet.
3097                         N, I uint16
3098
3099                         //mt:len32
3100                         Files []struct {
3101                                 Name string
3102
3103                                 //mt:len32
3104                                 Data []byte
3105                         }
3106                 }))(obj)).I
3107                 write16(w, uint16(x))
3108         }
3109         if len(((*(*(struct {
3110                 // N is the total number of ToCltMedia packets.
3111                 // I is the index of this packet.
3112                 N, I uint16
3113
3114                 //mt:len32
3115                 Files []struct {
3116                         Name string
3117
3118                         //mt:len32
3119                         Data []byte
3120                 }
3121         }))(obj)).Files)) > math.MaxUint32 {
3122                 chk(ErrTooLong)
3123         }
3124         {
3125                 x := uint32(len(((*(*(struct {
3126                         // N is the total number of ToCltMedia packets.
3127                         // I is the index of this packet.
3128                         N, I uint16
3129
3130                         //mt:len32
3131                         Files []struct {
3132                                 Name string
3133
3134                                 //mt:len32
3135                                 Data []byte
3136                         }
3137                 }))(obj)).Files)))
3138                 write32(w, uint32(x))
3139         }
3140         for local99 := range (*(*(struct {
3141                 // N is the total number of ToCltMedia packets.
3142                 // I is the index of this packet.
3143                 N, I uint16
3144
3145                 //mt:len32
3146                 Files []struct {
3147                         Name string
3148
3149                         //mt:len32
3150                         Data []byte
3151                 }
3152         }))(obj)).Files {
3153                 if len(([]byte((((*(*(struct {
3154                         // N is the total number of ToCltMedia packets.
3155                         // I is the index of this packet.
3156                         N, I uint16
3157
3158                         //mt:len32
3159                         Files []struct {
3160                                 Name string
3161
3162                                 //mt:len32
3163                                 Data []byte
3164                         }
3165                 }))(obj)).Files)[local99]).Name))) > math.MaxUint16 {
3166                         chk(ErrTooLong)
3167                 }
3168                 {
3169                         x := uint16(len(([]byte((((*(*(struct {
3170                                 // N is the total number of ToCltMedia packets.
3171                                 // I is the index of this packet.
3172                                 N, I uint16
3173
3174                                 //mt:len32
3175                                 Files []struct {
3176                                         Name string
3177
3178                                         //mt:len32
3179                                         Data []byte
3180                                 }
3181                         }))(obj)).Files)[local99]).Name))))
3182                         write16(w, uint16(x))
3183                 }
3184                 {
3185                         _, err := w.Write(([]byte((((*(*(struct {
3186                                 // N is the total number of ToCltMedia packets.
3187                                 // I is the index of this packet.
3188                                 N, I uint16
3189
3190                                 //mt:len32
3191                                 Files []struct {
3192                                         Name string
3193
3194                                         //mt:len32
3195                                         Data []byte
3196                                 }
3197                         }))(obj)).Files)[local99]).Name))[:])
3198                         chk(err)
3199                 }
3200                 if len(((((*(*(struct {
3201                         // N is the total number of ToCltMedia packets.
3202                         // I is the index of this packet.
3203                         N, I uint16
3204
3205                         //mt:len32
3206                         Files []struct {
3207                                 Name string
3208
3209                                 //mt:len32
3210                                 Data []byte
3211                         }
3212                 }))(obj)).Files)[local99]).Data)) > math.MaxUint32 {
3213                         chk(ErrTooLong)
3214                 }
3215                 {
3216                         x := uint32(len(((((*(*(struct {
3217                                 // N is the total number of ToCltMedia packets.
3218                                 // I is the index of this packet.
3219                                 N, I uint16
3220
3221                                 //mt:len32
3222                                 Files []struct {
3223                                         Name string
3224
3225                                         //mt:len32
3226                                         Data []byte
3227                                 }
3228                         }))(obj)).Files)[local99]).Data)))
3229                         write32(w, uint32(x))
3230                 }
3231                 {
3232                         _, err := w.Write(((((*(*(struct {
3233                                 // N is the total number of ToCltMedia packets.
3234                                 // I is the index of this packet.
3235                                 N, I uint16
3236
3237                                 //mt:len32
3238                                 Files []struct {
3239                                         Name string
3240
3241                                         //mt:len32
3242                                         Data []byte
3243                                 }
3244                         }))(obj)).Files)[local99]).Data)[:])
3245                         chk(err)
3246                 }
3247         }
3248 }
3249
3250 func (obj *ToCltMedia) deserialize(r io.Reader) {
3251         {
3252                 p := &(*(*(struct {
3253                         // N is the total number of ToCltMedia packets.
3254                         // I is the index of this packet.
3255                         N, I uint16
3256
3257                         //mt:len32
3258                         Files []struct {
3259                                 Name string
3260
3261                                 //mt:len32
3262                                 Data []byte
3263                         }
3264                 }))(obj)).N
3265                 *p = read16(r)
3266         }
3267         {
3268                 p := &(*(*(struct {
3269                         // N is the total number of ToCltMedia packets.
3270                         // I is the index of this packet.
3271                         N, I uint16
3272
3273                         //mt:len32
3274                         Files []struct {
3275                                 Name string
3276
3277                                 //mt:len32
3278                                 Data []byte
3279                         }
3280                 }))(obj)).I
3281                 *p = read16(r)
3282         }
3283         var local100 uint32
3284         {
3285                 p := &local100
3286                 *p = read32(r)
3287         }
3288         ((*(*(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) = make([]struct {
3301                 Name string
3302                 Data []byte
3303         }, local100)
3304         for local101 := range (*(*(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 {
3317                 var local102 []uint8
3318                 var local103 uint16
3319                 {
3320                         p := &local103
3321                         *p = read16(r)
3322                 }
3323                 (local102) = make([]uint8, local103)
3324                 {
3325                         _, err := io.ReadFull(r, (local102)[:])
3326                         chk(err)
3327                 }
3328                 ((((*(*(struct {
3329                         // N is the total number of ToCltMedia packets.
3330                         // I is the index of this packet.
3331                         N, I uint16
3332
3333                         //mt:len32
3334                         Files []struct {
3335                                 Name string
3336
3337                                 //mt:len32
3338                                 Data []byte
3339                         }
3340                 }))(obj)).Files)[local101]).Name) = string(local102)
3341                 var local104 uint32
3342                 {
3343                         p := &local104
3344                         *p = read32(r)
3345                 }
3346                 ((((*(*(struct {
3347                         // N is the total number of ToCltMedia packets.
3348                         // I is the index of this packet.
3349                         N, I uint16
3350
3351                         //mt:len32
3352                         Files []struct {
3353                                 Name string
3354
3355                                 //mt:len32
3356                                 Data []byte
3357                         }
3358                 }))(obj)).Files)[local101]).Data) = make([]byte, local104)
3359                 {
3360                         _, err := io.ReadFull(r, ((((*(*(struct {
3361                                 // N is the total number of ToCltMedia packets.
3362                                 // I is the index of this packet.
3363                                 N, I uint16
3364
3365                                 //mt:len32
3366                                 Files []struct {
3367                                         Name string
3368
3369                                         //mt:len32
3370                                         Data []byte
3371                                 }
3372                         }))(obj)).Files)[local101]).Data)[:])
3373                         chk(err)
3374                 }
3375         }
3376 }
3377
3378 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3379         {
3380                 ow := w
3381                 w := new(bytes.Buffer)
3382                 {
3383                         w := zlib.NewWriter(w)
3384                         {
3385                                 local105 := uint8(1)
3386                                 {
3387                                         x := local105
3388                                         write8(w, uint8(x))
3389                                 }
3390                         }
3391                         {
3392                                 x := (*(*(struct {
3393
3394                                         // See (de)serialize.fmt.
3395                                         Defs []NodeDef
3396                                 }))(obj)).Defs
3397                                 { // For ToCltNodeDefs.Defs.
3398                                         if len(x) > math.MaxUint16 {
3399                                                 chk(ErrTooLong)
3400                                         }
3401                                         write16(w, uint16(len(x)))
3402                                         var b bytes.Buffer
3403                                         for i := range x {
3404                                                 x[i].serialize(&b)
3405                                         }
3406                                         if b.Len() > math.MaxUint32 {
3407                                                 chk(ErrTooLong)
3408                                         }
3409                                         write32(w, uint32(b.Len()))
3410                                         _, err := b.WriteTo(w)
3411                                         chk(err)
3412                                 }
3413                         }
3414                         chk(w.Close())
3415                 }
3416                 {
3417                         buf := w
3418                         w := ow
3419                         if len((buf.Bytes())) > math.MaxUint32 {
3420                                 chk(ErrTooLong)
3421                         }
3422                         {
3423                                 x := uint32(len((buf.Bytes())))
3424                                 write32(w, uint32(x))
3425                         }
3426                         {
3427                                 _, err := w.Write((buf.Bytes())[:])
3428                                 chk(err)
3429                         }
3430                 }
3431         }
3432 }
3433
3434 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3435         {
3436                 var n uint32
3437                 {
3438                         p := &n
3439                         *p = read32(r)
3440                 }
3441                 r := &io.LimitedReader{R: r, N: int64(n)}
3442                 {
3443                         r, err := zlib.NewReader(byteReader{r})
3444                         chk(err)
3445                         {
3446                                 var local106 uint8
3447                                 local107 := uint8(1)
3448                                 {
3449                                         p := &local106
3450                                         *p = read8(r)
3451                                 }
3452                                 if local106 != local107 {
3453                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
3454                                 }
3455                         }
3456                         {
3457                                 p := &(*(*(struct {
3458
3459                                         // See (de)serialize.fmt.
3460                                         Defs []NodeDef
3461                                 }))(obj)).Defs
3462                                 { // For ToCltNodeDefs.Defs.
3463                                         *p = make([]NodeDef, read16(r))
3464                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3465                                         for i := range *p {
3466                                                 (*p)[i].deserialize(r)
3467                                         }
3468                                         if r.N > 0 {
3469                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3470                                         }
3471                                 }
3472                         }
3473                         chk(r.Close())
3474                 }
3475                 if r.N > 0 {
3476                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3477                 }
3478         }
3479 }
3480
3481 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3482         if len(((*(*(struct {
3483                 Files []struct {
3484                         Name       string
3485                         Base64SHA1 string
3486                 }
3487                 URL string
3488         }))(obj)).Files)) > math.MaxUint16 {
3489                 chk(ErrTooLong)
3490         }
3491         {
3492                 x := uint16(len(((*(*(struct {
3493                         Files []struct {
3494                                 Name       string
3495                                 Base64SHA1 string
3496                         }
3497                         URL string
3498                 }))(obj)).Files)))
3499                 write16(w, uint16(x))
3500         }
3501         for local108 := range (*(*(struct {
3502                 Files []struct {
3503                         Name       string
3504                         Base64SHA1 string
3505                 }
3506                 URL string
3507         }))(obj)).Files {
3508                 if len(([]byte((((*(*(struct {
3509                         Files []struct {
3510                                 Name       string
3511                                 Base64SHA1 string
3512                         }
3513                         URL string
3514                 }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
3515                         chk(ErrTooLong)
3516                 }
3517                 {
3518                         x := uint16(len(([]byte((((*(*(struct {
3519                                 Files []struct {
3520                                         Name       string
3521                                         Base64SHA1 string
3522                                 }
3523                                 URL string
3524                         }))(obj)).Files)[local108]).Name))))
3525                         write16(w, uint16(x))
3526                 }
3527                 {
3528                         _, err := w.Write(([]byte((((*(*(struct {
3529                                 Files []struct {
3530                                         Name       string
3531                                         Base64SHA1 string
3532                                 }
3533                                 URL string
3534                         }))(obj)).Files)[local108]).Name))[:])
3535                         chk(err)
3536                 }
3537                 if len(([]byte((((*(*(struct {
3538                         Files []struct {
3539                                 Name       string
3540                                 Base64SHA1 string
3541                         }
3542                         URL string
3543                 }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
3544                         chk(ErrTooLong)
3545                 }
3546                 {
3547                         x := uint16(len(([]byte((((*(*(struct {
3548                                 Files []struct {
3549                                         Name       string
3550                                         Base64SHA1 string
3551                                 }
3552                                 URL string
3553                         }))(obj)).Files)[local108]).Base64SHA1))))
3554                         write16(w, uint16(x))
3555                 }
3556                 {
3557                         _, err := w.Write(([]byte((((*(*(struct {
3558                                 Files []struct {
3559                                         Name       string
3560                                         Base64SHA1 string
3561                                 }
3562                                 URL string
3563                         }))(obj)).Files)[local108]).Base64SHA1))[:])
3564                         chk(err)
3565                 }
3566         }
3567         if len(([]byte((*(*(struct {
3568                 Files []struct {
3569                         Name       string
3570                         Base64SHA1 string
3571                 }
3572                 URL string
3573         }))(obj)).URL))) > math.MaxUint16 {
3574                 chk(ErrTooLong)
3575         }
3576         {
3577                 x := uint16(len(([]byte((*(*(struct {
3578                         Files []struct {
3579                                 Name       string
3580                                 Base64SHA1 string
3581                         }
3582                         URL string
3583                 }))(obj)).URL))))
3584                 write16(w, uint16(x))
3585         }
3586         {
3587                 _, err := w.Write(([]byte((*(*(struct {
3588                         Files []struct {
3589                                 Name       string
3590                                 Base64SHA1 string
3591                         }
3592                         URL string
3593                 }))(obj)).URL))[:])
3594                 chk(err)
3595         }
3596 }
3597
3598 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3599         var local109 uint16
3600         {
3601                 p := &local109
3602                 *p = read16(r)
3603         }
3604         ((*(*(struct {
3605                 Files []struct {
3606                         Name       string
3607                         Base64SHA1 string
3608                 }
3609                 URL string
3610         }))(obj)).Files) = make([]struct {
3611                 Name       string
3612                 Base64SHA1 string
3613         }, local109)
3614         for local110 := range (*(*(struct {
3615                 Files []struct {
3616                         Name       string
3617                         Base64SHA1 string
3618                 }
3619                 URL string
3620         }))(obj)).Files {
3621                 var local111 []uint8
3622                 var local112 uint16
3623                 {
3624                         p := &local112
3625                         *p = read16(r)
3626                 }
3627                 (local111) = make([]uint8, local112)
3628                 {
3629                         _, err := io.ReadFull(r, (local111)[:])
3630                         chk(err)
3631                 }
3632                 ((((*(*(struct {
3633                         Files []struct {
3634                                 Name       string
3635                                 Base64SHA1 string
3636                         }
3637                         URL string
3638                 }))(obj)).Files)[local110]).Name) = string(local111)
3639                 var local113 []uint8
3640                 var local114 uint16
3641                 {
3642                         p := &local114
3643                         *p = read16(r)
3644                 }
3645                 (local113) = make([]uint8, local114)
3646                 {
3647                         _, err := io.ReadFull(r, (local113)[:])
3648                         chk(err)
3649                 }
3650                 ((((*(*(struct {
3651                         Files []struct {
3652                                 Name       string
3653                                 Base64SHA1 string
3654                         }
3655                         URL string
3656                 }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
3657         }
3658         var local115 []uint8
3659         var local116 uint16
3660         {
3661                 p := &local116
3662                 *p = read16(r)
3663         }
3664         (local115) = make([]uint8, local116)
3665         {
3666                 _, err := io.ReadFull(r, (local115)[:])
3667                 chk(err)
3668         }
3669         ((*(*(struct {
3670                 Files []struct {
3671                         Name       string
3672                         Base64SHA1 string
3673                 }
3674                 URL string
3675         }))(obj)).URL) = string(local115)
3676 }
3677
3678 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3679         {
3680                 ow := w
3681                 w := new(bytes.Buffer)
3682                 {
3683                         w := zlib.NewWriter(w)
3684                         {
3685                                 local117 := uint8(0)
3686                                 {
3687                                         x := local117
3688                                         write8(w, uint8(x))
3689                                 }
3690                         }
3691                         if len(((*(*(struct {
3692                                 Defs    []ItemDef
3693                                 Aliases []struct{ Alias, Orig string }
3694                         }))(obj)).Defs)) > math.MaxUint16 {
3695                                 chk(ErrTooLong)
3696                         }
3697                         {
3698                                 x := uint16(len(((*(*(struct {
3699                                         Defs    []ItemDef
3700                                         Aliases []struct{ Alias, Orig string }
3701                                 }))(obj)).Defs)))
3702                                 write16(w, uint16(x))
3703                         }
3704                         for local118 := range (*(*(struct {
3705                                 Defs    []ItemDef
3706                                 Aliases []struct{ Alias, Orig string }
3707                         }))(obj)).Defs {
3708                                 if err := pcall(func() {
3709                                         (((*(*(struct {
3710                                                 Defs    []ItemDef
3711                                                 Aliases []struct{ Alias, Orig string }
3712                                         }))(obj)).Defs)[local118]).serialize(w)
3713                                 }); err != nil {
3714                                         if err == io.EOF {
3715                                                 chk(io.EOF)
3716                                         }
3717                                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemDef", err))
3718                                 }
3719                         }
3720                         if len(((*(*(struct {
3721                                 Defs    []ItemDef
3722                                 Aliases []struct{ Alias, Orig string }
3723                         }))(obj)).Aliases)) > math.MaxUint16 {
3724                                 chk(ErrTooLong)
3725                         }
3726                         {
3727                                 x := uint16(len(((*(*(struct {
3728                                         Defs    []ItemDef
3729                                         Aliases []struct{ Alias, Orig string }
3730                                 }))(obj)).Aliases)))
3731                                 write16(w, uint16(x))
3732                         }
3733                         for local119 := range (*(*(struct {
3734                                 Defs    []ItemDef
3735                                 Aliases []struct{ Alias, Orig string }
3736                         }))(obj)).Aliases {
3737                                 if len(([]byte((((*(*(struct {
3738                                         Defs    []ItemDef
3739                                         Aliases []struct{ Alias, Orig string }
3740                                 }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
3741                                         chk(ErrTooLong)
3742                                 }
3743                                 {
3744                                         x := uint16(len(([]byte((((*(*(struct {
3745                                                 Defs    []ItemDef
3746                                                 Aliases []struct{ Alias, Orig string }
3747                                         }))(obj)).Aliases)[local119]).Alias))))
3748                                         write16(w, uint16(x))
3749                                 }
3750                                 {
3751                                         _, err := w.Write(([]byte((((*(*(struct {
3752                                                 Defs    []ItemDef
3753                                                 Aliases []struct{ Alias, Orig string }
3754                                         }))(obj)).Aliases)[local119]).Alias))[:])
3755                                         chk(err)
3756                                 }
3757                                 if len(([]byte((((*(*(struct {
3758                                         Defs    []ItemDef
3759                                         Aliases []struct{ Alias, Orig string }
3760                                 }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
3761                                         chk(ErrTooLong)
3762                                 }
3763                                 {
3764                                         x := uint16(len(([]byte((((*(*(struct {
3765                                                 Defs    []ItemDef
3766                                                 Aliases []struct{ Alias, Orig string }
3767                                         }))(obj)).Aliases)[local119]).Orig))))
3768                                         write16(w, uint16(x))
3769                                 }
3770                                 {
3771                                         _, err := w.Write(([]byte((((*(*(struct {
3772                                                 Defs    []ItemDef
3773                                                 Aliases []struct{ Alias, Orig string }
3774                                         }))(obj)).Aliases)[local119]).Orig))[:])
3775                                         chk(err)
3776                                 }
3777                         }
3778                         chk(w.Close())
3779                 }
3780                 {
3781                         buf := w
3782                         w := ow
3783                         if len((buf.Bytes())) > math.MaxUint32 {
3784                                 chk(ErrTooLong)
3785                         }
3786                         {
3787                                 x := uint32(len((buf.Bytes())))
3788                                 write32(w, uint32(x))
3789                         }
3790                         {
3791                                 _, err := w.Write((buf.Bytes())[:])
3792                                 chk(err)
3793                         }
3794                 }
3795         }
3796 }
3797
3798 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3799         {
3800                 var n uint32
3801                 {
3802                         p := &n
3803                         *p = read32(r)
3804                 }
3805                 r := &io.LimitedReader{R: r, N: int64(n)}
3806                 {
3807                         r, err := zlib.NewReader(byteReader{r})
3808                         chk(err)
3809                         {
3810                                 var local120 uint8
3811                                 local121 := uint8(0)
3812                                 {
3813                                         p := &local120
3814                                         *p = read8(r)
3815                                 }
3816                                 if local120 != local121 {
3817                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
3818                                 }
3819                         }
3820                         var local122 uint16
3821                         {
3822                                 p := &local122
3823                                 *p = read16(r)
3824                         }
3825                         ((*(*(struct {
3826                                 Defs    []ItemDef
3827                                 Aliases []struct{ Alias, Orig string }
3828                         }))(obj)).Defs) = make([]ItemDef, local122)
3829                         for local123 := range (*(*(struct {
3830                                 Defs    []ItemDef
3831                                 Aliases []struct{ Alias, Orig string }
3832                         }))(obj)).Defs {
3833                                 if err := pcall(func() {
3834                                         (((*(*(struct {
3835                                                 Defs    []ItemDef
3836                                                 Aliases []struct{ Alias, Orig string }
3837                                         }))(obj)).Defs)[local123]).deserialize(r)
3838                                 }); err != nil {
3839                                         if err == io.EOF {
3840                                                 chk(io.EOF)
3841                                         }
3842                                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemDef", err))
3843                                 }
3844                         }
3845                         var local124 uint16
3846                         {
3847                                 p := &local124
3848                                 *p = read16(r)
3849                         }
3850                         ((*(*(struct {
3851                                 Defs    []ItemDef
3852                                 Aliases []struct{ Alias, Orig string }
3853                         }))(obj)).Aliases) = make([]struct {
3854                                 Alias string
3855                                 Orig  string
3856                         }, local124)
3857                         for local125 := range (*(*(struct {
3858                                 Defs    []ItemDef
3859                                 Aliases []struct{ Alias, Orig string }
3860                         }))(obj)).Aliases {
3861                                 var local126 []uint8
3862                                 var local127 uint16
3863                                 {
3864                                         p := &local127
3865                                         *p = read16(r)
3866                                 }
3867                                 (local126) = make([]uint8, local127)
3868                                 {
3869                                         _, err := io.ReadFull(r, (local126)[:])
3870                                         chk(err)
3871                                 }
3872                                 ((((*(*(struct {
3873                                         Defs    []ItemDef
3874                                         Aliases []struct{ Alias, Orig string }
3875                                 }))(obj)).Aliases)[local125]).Alias) = string(local126)
3876                                 var local128 []uint8
3877                                 var local129 uint16
3878                                 {
3879                                         p := &local129
3880                                         *p = read16(r)
3881                                 }
3882                                 (local128) = make([]uint8, local129)
3883                                 {
3884                                         _, err := io.ReadFull(r, (local128)[:])
3885                                         chk(err)
3886                                 }
3887                                 ((((*(*(struct {
3888                                         Defs    []ItemDef
3889                                         Aliases []struct{ Alias, Orig string }
3890                                 }))(obj)).Aliases)[local125]).Orig) = string(local128)
3891                         }
3892                         chk(r.Close())
3893                 }
3894                 if r.N > 0 {
3895                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3896                 }
3897         }
3898 }
3899
3900 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3901         if err := pcall(func() {
3902                 ((*(*(struct {
3903                         ID      SoundID
3904                         Name    string
3905                         Gain    float32
3906                         SrcType SoundSrcType
3907                         Pos
3908                         SrcAOID   AOID
3909                         Loop      bool
3910                         Fade      float32
3911                         Pitch     float32
3912                         Ephemeral bool
3913                 }))(obj)).ID).serialize(w)
3914         }); err != nil {
3915                 if err == io.EOF {
3916                         chk(io.EOF)
3917                 }
3918                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
3919         }
3920         if len(([]byte((*(*(struct {
3921                 ID      SoundID
3922                 Name    string
3923                 Gain    float32
3924                 SrcType SoundSrcType
3925                 Pos
3926                 SrcAOID   AOID
3927                 Loop      bool
3928                 Fade      float32
3929                 Pitch     float32
3930                 Ephemeral bool
3931         }))(obj)).Name))) > math.MaxUint16 {
3932                 chk(ErrTooLong)
3933         }
3934         {
3935                 x := uint16(len(([]byte((*(*(struct {
3936                         ID      SoundID
3937                         Name    string
3938                         Gain    float32
3939                         SrcType SoundSrcType
3940                         Pos
3941                         SrcAOID   AOID
3942                         Loop      bool
3943                         Fade      float32
3944                         Pitch     float32
3945                         Ephemeral bool
3946                 }))(obj)).Name))))
3947                 write16(w, uint16(x))
3948         }
3949         {
3950                 _, err := w.Write(([]byte((*(*(struct {
3951                         ID      SoundID
3952                         Name    string
3953                         Gain    float32
3954                         SrcType SoundSrcType
3955                         Pos
3956                         SrcAOID   AOID
3957                         Loop      bool
3958                         Fade      float32
3959                         Pitch     float32
3960                         Ephemeral bool
3961                 }))(obj)).Name))[:])
3962                 chk(err)
3963         }
3964         {
3965                 x := (*(*(struct {
3966                         ID      SoundID
3967                         Name    string
3968                         Gain    float32
3969                         SrcType SoundSrcType
3970                         Pos
3971                         SrcAOID   AOID
3972                         Loop      bool
3973                         Fade      float32
3974                         Pitch     float32
3975                         Ephemeral bool
3976                 }))(obj)).Gain
3977                 write32(w, math.Float32bits(x))
3978         }
3979         if err := pcall(func() {
3980                 ((*(*(struct {
3981                         ID      SoundID
3982                         Name    string
3983                         Gain    float32
3984                         SrcType SoundSrcType
3985                         Pos
3986                         SrcAOID   AOID
3987                         Loop      bool
3988                         Fade      float32
3989                         Pitch     float32
3990                         Ephemeral bool
3991                 }))(obj)).SrcType).serialize(w)
3992         }); err != nil {
3993                 if err == io.EOF {
3994                         chk(io.EOF)
3995                 }
3996                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundSrcType", err))
3997         }
3998         if err := pcall(func() {
3999                 ((*(*(struct {
4000                         ID      SoundID
4001                         Name    string
4002                         Gain    float32
4003                         SrcType SoundSrcType
4004                         Pos
4005                         SrcAOID   AOID
4006                         Loop      bool
4007                         Fade      float32
4008                         Pitch     float32
4009                         Ephemeral bool
4010                 }))(obj)).Pos).serialize(w)
4011         }); err != nil {
4012                 if err == io.EOF {
4013                         chk(io.EOF)
4014                 }
4015                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
4016         }
4017         if err := pcall(func() {
4018                 ((*(*(struct {
4019                         ID      SoundID
4020                         Name    string
4021                         Gain    float32
4022                         SrcType SoundSrcType
4023                         Pos
4024                         SrcAOID   AOID
4025                         Loop      bool
4026                         Fade      float32
4027                         Pitch     float32
4028                         Ephemeral bool
4029                 }))(obj)).SrcAOID).serialize(w)
4030         }); err != nil {
4031                 if err == io.EOF {
4032                         chk(io.EOF)
4033                 }
4034                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
4035         }
4036         {
4037                 x := (*(*(struct {
4038                         ID      SoundID
4039                         Name    string
4040                         Gain    float32
4041                         SrcType SoundSrcType
4042                         Pos
4043                         SrcAOID   AOID
4044                         Loop      bool
4045                         Fade      float32
4046                         Pitch     float32
4047                         Ephemeral bool
4048                 }))(obj)).Loop
4049                 if x {
4050                         write8(w, 1)
4051                 } else {
4052                         write8(w, 0)
4053                 }
4054         }
4055         {
4056                 x := (*(*(struct {
4057                         ID      SoundID
4058                         Name    string
4059                         Gain    float32
4060                         SrcType SoundSrcType
4061                         Pos
4062                         SrcAOID   AOID
4063                         Loop      bool
4064                         Fade      float32
4065                         Pitch     float32
4066                         Ephemeral bool
4067                 }))(obj)).Fade
4068                 write32(w, math.Float32bits(x))
4069         }
4070         {
4071                 x := (*(*(struct {
4072                         ID      SoundID
4073                         Name    string
4074                         Gain    float32
4075                         SrcType SoundSrcType
4076                         Pos
4077                         SrcAOID   AOID
4078                         Loop      bool
4079                         Fade      float32
4080                         Pitch     float32
4081                         Ephemeral bool
4082                 }))(obj)).Pitch
4083                 write32(w, math.Float32bits(x))
4084         }
4085         {
4086                 x := (*(*(struct {
4087                         ID      SoundID
4088                         Name    string
4089                         Gain    float32
4090                         SrcType SoundSrcType
4091                         Pos
4092                         SrcAOID   AOID
4093                         Loop      bool
4094                         Fade      float32
4095                         Pitch     float32
4096                         Ephemeral bool
4097                 }))(obj)).Ephemeral
4098                 if x {
4099                         write8(w, 1)
4100                 } else {
4101                         write8(w, 0)
4102                 }
4103         }
4104 }
4105
4106 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4107         if err := pcall(func() {
4108                 ((*(*(struct {
4109                         ID      SoundID
4110                         Name    string
4111                         Gain    float32
4112                         SrcType SoundSrcType
4113                         Pos
4114                         SrcAOID   AOID
4115                         Loop      bool
4116                         Fade      float32
4117                         Pitch     float32
4118                         Ephemeral bool
4119                 }))(obj)).ID).deserialize(r)
4120         }); err != nil {
4121                 if err == io.EOF {
4122                         chk(io.EOF)
4123                 }
4124                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
4125         }
4126         var local130 []uint8
4127         var local131 uint16
4128         {
4129                 p := &local131
4130                 *p = read16(r)
4131         }
4132         (local130) = make([]uint8, local131)
4133         {
4134                 _, err := io.ReadFull(r, (local130)[:])
4135                 chk(err)
4136         }
4137         ((*(*(struct {
4138                 ID      SoundID
4139                 Name    string
4140                 Gain    float32
4141                 SrcType SoundSrcType
4142                 Pos
4143                 SrcAOID   AOID
4144                 Loop      bool
4145                 Fade      float32
4146                 Pitch     float32
4147                 Ephemeral bool
4148         }))(obj)).Name) = string(local130)
4149         {
4150                 p := &(*(*(struct {
4151                         ID      SoundID
4152                         Name    string
4153                         Gain    float32
4154                         SrcType SoundSrcType
4155                         Pos
4156                         SrcAOID   AOID
4157                         Loop      bool
4158                         Fade      float32
4159                         Pitch     float32
4160                         Ephemeral bool
4161                 }))(obj)).Gain
4162                 *p = math.Float32frombits(read32(r))
4163         }
4164         if err := pcall(func() {
4165                 ((*(*(struct {
4166                         ID      SoundID
4167                         Name    string
4168                         Gain    float32
4169                         SrcType SoundSrcType
4170                         Pos
4171                         SrcAOID   AOID
4172                         Loop      bool
4173                         Fade      float32
4174                         Pitch     float32
4175                         Ephemeral bool
4176                 }))(obj)).SrcType).deserialize(r)
4177         }); err != nil {
4178                 if err == io.EOF {
4179                         chk(io.EOF)
4180                 }
4181                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundSrcType", err))
4182         }
4183         if err := pcall(func() {
4184                 ((*(*(struct {
4185                         ID      SoundID
4186                         Name    string
4187                         Gain    float32
4188                         SrcType SoundSrcType
4189                         Pos
4190                         SrcAOID   AOID
4191                         Loop      bool
4192                         Fade      float32
4193                         Pitch     float32
4194                         Ephemeral bool
4195                 }))(obj)).Pos).deserialize(r)
4196         }); err != nil {
4197                 if err == io.EOF {
4198                         chk(io.EOF)
4199                 }
4200                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
4201         }
4202         if err := pcall(func() {
4203                 ((*(*(struct {
4204                         ID      SoundID
4205                         Name    string
4206                         Gain    float32
4207                         SrcType SoundSrcType
4208                         Pos
4209                         SrcAOID   AOID
4210                         Loop      bool
4211                         Fade      float32
4212                         Pitch     float32
4213                         Ephemeral bool
4214                 }))(obj)).SrcAOID).deserialize(r)
4215         }); err != nil {
4216                 if err == io.EOF {
4217                         chk(io.EOF)
4218                 }
4219                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
4220         }
4221         {
4222                 p := &(*(*(struct {
4223                         ID      SoundID
4224                         Name    string
4225                         Gain    float32
4226                         SrcType SoundSrcType
4227                         Pos
4228                         SrcAOID   AOID
4229                         Loop      bool
4230                         Fade      float32
4231                         Pitch     float32
4232                         Ephemeral bool
4233                 }))(obj)).Loop
4234                 switch n := read8(r); n {
4235                 case 0:
4236                         *p = false
4237                 case 1:
4238                         *p = true
4239                 default:
4240                         chk(fmt.Errorf("invalid bool: %d", n))
4241                 }
4242         }
4243         {
4244                 p := &(*(*(struct {
4245                         ID      SoundID
4246                         Name    string
4247                         Gain    float32
4248                         SrcType SoundSrcType
4249                         Pos
4250                         SrcAOID   AOID
4251                         Loop      bool
4252                         Fade      float32
4253                         Pitch     float32
4254                         Ephemeral bool
4255                 }))(obj)).Fade
4256                 *p = math.Float32frombits(read32(r))
4257         }
4258         {
4259                 p := &(*(*(struct {
4260                         ID      SoundID
4261                         Name    string
4262                         Gain    float32
4263                         SrcType SoundSrcType
4264                         Pos
4265                         SrcAOID   AOID
4266                         Loop      bool
4267                         Fade      float32
4268                         Pitch     float32
4269                         Ephemeral bool
4270                 }))(obj)).Pitch
4271                 *p = math.Float32frombits(read32(r))
4272         }
4273         {
4274                 p := &(*(*(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)).Ephemeral
4286                 switch n := read8(r); n {
4287                 case 0:
4288                         *p = false
4289                 case 1:
4290                         *p = true
4291                 default:
4292                         chk(fmt.Errorf("invalid bool: %d", n))
4293                 }
4294         }
4295 }
4296
4297 func (obj *ToCltStopSound) serialize(w io.Writer) {
4298         if err := pcall(func() {
4299                 ((*(*(struct {
4300                         ID SoundID
4301                 }))(obj)).ID).serialize(w)
4302         }); err != nil {
4303                 if err == io.EOF {
4304                         chk(io.EOF)
4305                 }
4306                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
4307         }
4308 }
4309
4310 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4311         if err := pcall(func() {
4312                 ((*(*(struct {
4313                         ID SoundID
4314                 }))(obj)).ID).deserialize(r)
4315         }); err != nil {
4316                 if err == io.EOF {
4317                         chk(io.EOF)
4318                 }
4319                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
4320         }
4321 }
4322
4323 func (obj *ToCltPrivs) serialize(w io.Writer) {
4324         if len(((*(*(struct {
4325                 Privs []string
4326         }))(obj)).Privs)) > math.MaxUint16 {
4327                 chk(ErrTooLong)
4328         }
4329         {
4330                 x := uint16(len(((*(*(struct {
4331                         Privs []string
4332                 }))(obj)).Privs)))
4333                 write16(w, uint16(x))
4334         }
4335         for local132 := range (*(*(struct {
4336                 Privs []string
4337         }))(obj)).Privs {
4338                 if len(([]byte(((*(*(struct {
4339                         Privs []string
4340                 }))(obj)).Privs)[local132]))) > math.MaxUint16 {
4341                         chk(ErrTooLong)
4342                 }
4343                 {
4344                         x := uint16(len(([]byte(((*(*(struct {
4345                                 Privs []string
4346                         }))(obj)).Privs)[local132]))))
4347                         write16(w, uint16(x))
4348                 }
4349                 {
4350                         _, err := w.Write(([]byte(((*(*(struct {
4351                                 Privs []string
4352                         }))(obj)).Privs)[local132]))[:])
4353                         chk(err)
4354                 }
4355         }
4356 }
4357
4358 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4359         var local133 uint16
4360         {
4361                 p := &local133
4362                 *p = read16(r)
4363         }
4364         ((*(*(struct {
4365                 Privs []string
4366         }))(obj)).Privs) = make([]string, local133)
4367         for local134 := range (*(*(struct {
4368                 Privs []string
4369         }))(obj)).Privs {
4370                 var local135 []uint8
4371                 var local136 uint16
4372                 {
4373                         p := &local136
4374                         *p = read16(r)
4375                 }
4376                 (local135) = make([]uint8, local136)
4377                 {
4378                         _, err := io.ReadFull(r, (local135)[:])
4379                         chk(err)
4380                 }
4381                 (((*(*(struct {
4382                         Privs []string
4383                 }))(obj)).Privs)[local134]) = string(local135)
4384         }
4385 }
4386
4387 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4388         if len(([]byte((*(*(struct {
4389                 //mt:len32
4390                 Formspec string
4391         }))(obj)).Formspec))) > math.MaxUint32 {
4392                 chk(ErrTooLong)
4393         }
4394         {
4395                 x := uint32(len(([]byte((*(*(struct {
4396                         //mt:len32
4397                         Formspec string
4398                 }))(obj)).Formspec))))
4399                 write32(w, uint32(x))
4400         }
4401         {
4402                 _, err := w.Write(([]byte((*(*(struct {
4403                         //mt:len32
4404                         Formspec string
4405                 }))(obj)).Formspec))[:])
4406                 chk(err)
4407         }
4408 }
4409
4410 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4411         var local137 []uint8
4412         var local138 uint32
4413         {
4414                 p := &local138
4415                 *p = read32(r)
4416         }
4417         (local137) = make([]uint8, local138)
4418         {
4419                 _, err := io.ReadFull(r, (local137)[:])
4420                 chk(err)
4421         }
4422         ((*(*(struct {
4423                 //mt:len32
4424                 Formspec string
4425         }))(obj)).Formspec) = string(local137)
4426 }
4427
4428 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4429         if len(([]byte((*(*(struct {
4430                 Name string
4431                 Keep bool
4432                 Len  uint16 // deprecated
4433
4434                 //mt:raw
4435                 Inv string
4436         }))(obj)).Name))) > math.MaxUint16 {
4437                 chk(ErrTooLong)
4438         }
4439         {
4440                 x := uint16(len(([]byte((*(*(struct {
4441                         Name string
4442                         Keep bool
4443                         Len  uint16 // deprecated
4444
4445                         //mt:raw
4446                         Inv string
4447                 }))(obj)).Name))))
4448                 write16(w, uint16(x))
4449         }
4450         {
4451                 _, err := w.Write(([]byte((*(*(struct {
4452                         Name string
4453                         Keep bool
4454                         Len  uint16 // deprecated
4455
4456                         //mt:raw
4457                         Inv string
4458                 }))(obj)).Name))[:])
4459                 chk(err)
4460         }
4461         {
4462                 x := (*(*(struct {
4463                         Name string
4464                         Keep bool
4465                         Len  uint16 // deprecated
4466
4467                         //mt:raw
4468                         Inv string
4469                 }))(obj)).Keep
4470                 if x {
4471                         write8(w, 1)
4472                 } else {
4473                         write8(w, 0)
4474                 }
4475         }
4476         {
4477                 x := (*(*(struct {
4478                         Name string
4479                         Keep bool
4480                         Len  uint16 // deprecated
4481
4482                         //mt:raw
4483                         Inv string
4484                 }))(obj)).Len
4485                 write16(w, uint16(x))
4486         }
4487         {
4488                 _, err := w.Write(([]byte((*(*(struct {
4489                         Name string
4490                         Keep bool
4491                         Len  uint16 // deprecated
4492
4493                         //mt:raw
4494                         Inv string
4495                 }))(obj)).Inv))[:])
4496                 chk(err)
4497         }
4498 }
4499
4500 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4501         var local139 []uint8
4502         var local140 uint16
4503         {
4504                 p := &local140
4505                 *p = read16(r)
4506         }
4507         (local139) = make([]uint8, local140)
4508         {
4509                 _, err := io.ReadFull(r, (local139)[:])
4510                 chk(err)
4511         }
4512         ((*(*(struct {
4513                 Name string
4514                 Keep bool
4515                 Len  uint16 // deprecated
4516
4517                 //mt:raw
4518                 Inv string
4519         }))(obj)).Name) = string(local139)
4520         {
4521                 p := &(*(*(struct {
4522                         Name string
4523                         Keep bool
4524                         Len  uint16 // deprecated
4525
4526                         //mt:raw
4527                         Inv string
4528                 }))(obj)).Keep
4529                 switch n := read8(r); n {
4530                 case 0:
4531                         *p = false
4532                 case 1:
4533                         *p = true
4534                 default:
4535                         chk(fmt.Errorf("invalid bool: %d", n))
4536                 }
4537         }
4538         {
4539                 p := &(*(*(struct {
4540                         Name string
4541                         Keep bool
4542                         Len  uint16 // deprecated
4543
4544                         //mt:raw
4545                         Inv string
4546                 }))(obj)).Len
4547                 *p = read16(r)
4548         }
4549         var local141 []uint8
4550         {
4551                 var err error
4552                 (local141), err = io.ReadAll(r)
4553                 chk(err)
4554         }
4555         ((*(*(struct {
4556                 Name string
4557                 Keep bool
4558                 Len  uint16 // deprecated
4559
4560                 //mt:raw
4561                 Inv string
4562         }))(obj)).Inv) = string(local141)
4563 }
4564
4565 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4566         if len(([]byte((*(*(struct {
4567                 //mt:len32
4568                 Formspec string
4569
4570                 Formname string
4571         }))(obj)).Formspec))) > math.MaxUint32 {
4572                 chk(ErrTooLong)
4573         }
4574         {
4575                 x := uint32(len(([]byte((*(*(struct {
4576                         //mt:len32
4577                         Formspec string
4578
4579                         Formname string
4580                 }))(obj)).Formspec))))
4581                 write32(w, uint32(x))
4582         }
4583         {
4584                 _, err := w.Write(([]byte((*(*(struct {
4585                         //mt:len32
4586                         Formspec string
4587
4588                         Formname string
4589                 }))(obj)).Formspec))[:])
4590                 chk(err)
4591         }
4592         if len(([]byte((*(*(struct {
4593                 //mt:len32
4594                 Formspec string
4595
4596                 Formname string
4597         }))(obj)).Formname))) > math.MaxUint16 {
4598                 chk(ErrTooLong)
4599         }
4600         {
4601                 x := uint16(len(([]byte((*(*(struct {
4602                         //mt:len32
4603                         Formspec string
4604
4605                         Formname string
4606                 }))(obj)).Formname))))
4607                 write16(w, uint16(x))
4608         }
4609         {
4610                 _, err := w.Write(([]byte((*(*(struct {
4611                         //mt:len32
4612                         Formspec string
4613
4614                         Formname string
4615                 }))(obj)).Formname))[:])
4616                 chk(err)
4617         }
4618 }
4619
4620 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4621         var local142 []uint8
4622         var local143 uint32
4623         {
4624                 p := &local143
4625                 *p = read32(r)
4626         }
4627         (local142) = make([]uint8, local143)
4628         {
4629                 _, err := io.ReadFull(r, (local142)[:])
4630                 chk(err)
4631         }
4632         ((*(*(struct {
4633                 //mt:len32
4634                 Formspec string
4635
4636                 Formname string
4637         }))(obj)).Formspec) = string(local142)
4638         var local144 []uint8
4639         var local145 uint16
4640         {
4641                 p := &local145
4642                 *p = read16(r)
4643         }
4644         (local144) = make([]uint8, local145)
4645         {
4646                 _, err := io.ReadFull(r, (local144)[:])
4647                 chk(err)
4648         }
4649         ((*(*(struct {
4650                 //mt:len32
4651                 Formspec string
4652
4653                 Formname string
4654         }))(obj)).Formname) = string(local144)
4655 }
4656
4657 func (obj *ToCltMovement) serialize(w io.Writer) {
4658         {
4659                 x := (*(*(struct {
4660                         DefaultAccel, AirAccel, FastAccel,
4661                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4662                         Fluidity, Smoothing, Sink,
4663                         Gravity float32
4664                 }))(obj)).DefaultAccel
4665                 write32(w, math.Float32bits(x))
4666         }
4667         {
4668                 x := (*(*(struct {
4669                         DefaultAccel, AirAccel, FastAccel,
4670                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4671                         Fluidity, Smoothing, Sink,
4672                         Gravity float32
4673                 }))(obj)).AirAccel
4674                 write32(w, math.Float32bits(x))
4675         }
4676         {
4677                 x := (*(*(struct {
4678                         DefaultAccel, AirAccel, FastAccel,
4679                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4680                         Fluidity, Smoothing, Sink,
4681                         Gravity float32
4682                 }))(obj)).FastAccel
4683                 write32(w, math.Float32bits(x))
4684         }
4685         {
4686                 x := (*(*(struct {
4687                         DefaultAccel, AirAccel, FastAccel,
4688                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4689                         Fluidity, Smoothing, Sink,
4690                         Gravity float32
4691                 }))(obj)).WalkSpeed
4692                 write32(w, math.Float32bits(x))
4693         }
4694         {
4695                 x := (*(*(struct {
4696                         DefaultAccel, AirAccel, FastAccel,
4697                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4698                         Fluidity, Smoothing, Sink,
4699                         Gravity float32
4700                 }))(obj)).CrouchSpeed
4701                 write32(w, math.Float32bits(x))
4702         }
4703         {
4704                 x := (*(*(struct {
4705                         DefaultAccel, AirAccel, FastAccel,
4706                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4707                         Fluidity, Smoothing, Sink,
4708                         Gravity float32
4709                 }))(obj)).FastSpeed
4710                 write32(w, math.Float32bits(x))
4711         }
4712         {
4713                 x := (*(*(struct {
4714                         DefaultAccel, AirAccel, FastAccel,
4715                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4716                         Fluidity, Smoothing, Sink,
4717                         Gravity float32
4718                 }))(obj)).ClimbSpeed
4719                 write32(w, math.Float32bits(x))
4720         }
4721         {
4722                 x := (*(*(struct {
4723                         DefaultAccel, AirAccel, FastAccel,
4724                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4725                         Fluidity, Smoothing, Sink,
4726                         Gravity float32
4727                 }))(obj)).JumpSpeed
4728                 write32(w, math.Float32bits(x))
4729         }
4730         {
4731                 x := (*(*(struct {
4732                         DefaultAccel, AirAccel, FastAccel,
4733                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4734                         Fluidity, Smoothing, Sink,
4735                         Gravity float32
4736                 }))(obj)).Fluidity
4737                 write32(w, math.Float32bits(x))
4738         }
4739         {
4740                 x := (*(*(struct {
4741                         DefaultAccel, AirAccel, FastAccel,
4742                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4743                         Fluidity, Smoothing, Sink,
4744                         Gravity float32
4745                 }))(obj)).Smoothing
4746                 write32(w, math.Float32bits(x))
4747         }
4748         {
4749                 x := (*(*(struct {
4750                         DefaultAccel, AirAccel, FastAccel,
4751                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4752                         Fluidity, Smoothing, Sink,
4753                         Gravity float32
4754                 }))(obj)).Sink
4755                 write32(w, math.Float32bits(x))
4756         }
4757         {
4758                 x := (*(*(struct {
4759                         DefaultAccel, AirAccel, FastAccel,
4760                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4761                         Fluidity, Smoothing, Sink,
4762                         Gravity float32
4763                 }))(obj)).Gravity
4764                 write32(w, math.Float32bits(x))
4765         }
4766 }
4767
4768 func (obj *ToCltMovement) deserialize(r io.Reader) {
4769         {
4770                 p := &(*(*(struct {
4771                         DefaultAccel, AirAccel, FastAccel,
4772                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4773                         Fluidity, Smoothing, Sink,
4774                         Gravity float32
4775                 }))(obj)).DefaultAccel
4776                 *p = math.Float32frombits(read32(r))
4777         }
4778         {
4779                 p := &(*(*(struct {
4780                         DefaultAccel, AirAccel, FastAccel,
4781                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4782                         Fluidity, Smoothing, Sink,
4783                         Gravity float32
4784                 }))(obj)).AirAccel
4785                 *p = math.Float32frombits(read32(r))
4786         }
4787         {
4788                 p := &(*(*(struct {
4789                         DefaultAccel, AirAccel, FastAccel,
4790                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4791                         Fluidity, Smoothing, Sink,
4792                         Gravity float32
4793                 }))(obj)).FastAccel
4794                 *p = math.Float32frombits(read32(r))
4795         }
4796         {
4797                 p := &(*(*(struct {
4798                         DefaultAccel, AirAccel, FastAccel,
4799                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4800                         Fluidity, Smoothing, Sink,
4801                         Gravity float32
4802                 }))(obj)).WalkSpeed
4803                 *p = math.Float32frombits(read32(r))
4804         }
4805         {
4806                 p := &(*(*(struct {
4807                         DefaultAccel, AirAccel, FastAccel,
4808                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4809                         Fluidity, Smoothing, Sink,
4810                         Gravity float32
4811                 }))(obj)).CrouchSpeed
4812                 *p = math.Float32frombits(read32(r))
4813         }
4814         {
4815                 p := &(*(*(struct {
4816                         DefaultAccel, AirAccel, FastAccel,
4817                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4818                         Fluidity, Smoothing, Sink,
4819                         Gravity float32
4820                 }))(obj)).FastSpeed
4821                 *p = math.Float32frombits(read32(r))
4822         }
4823         {
4824                 p := &(*(*(struct {
4825                         DefaultAccel, AirAccel, FastAccel,
4826                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4827                         Fluidity, Smoothing, Sink,
4828                         Gravity float32
4829                 }))(obj)).ClimbSpeed
4830                 *p = math.Float32frombits(read32(r))
4831         }
4832         {
4833                 p := &(*(*(struct {
4834                         DefaultAccel, AirAccel, FastAccel,
4835                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4836                         Fluidity, Smoothing, Sink,
4837                         Gravity float32
4838                 }))(obj)).JumpSpeed
4839                 *p = math.Float32frombits(read32(r))
4840         }
4841         {
4842                 p := &(*(*(struct {
4843                         DefaultAccel, AirAccel, FastAccel,
4844                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4845                         Fluidity, Smoothing, Sink,
4846                         Gravity float32
4847                 }))(obj)).Fluidity
4848                 *p = math.Float32frombits(read32(r))
4849         }
4850         {
4851                 p := &(*(*(struct {
4852                         DefaultAccel, AirAccel, FastAccel,
4853                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4854                         Fluidity, Smoothing, Sink,
4855                         Gravity float32
4856                 }))(obj)).Smoothing
4857                 *p = math.Float32frombits(read32(r))
4858         }
4859         {
4860                 p := &(*(*(struct {
4861                         DefaultAccel, AirAccel, FastAccel,
4862                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4863                         Fluidity, Smoothing, Sink,
4864                         Gravity float32
4865                 }))(obj)).Sink
4866                 *p = math.Float32frombits(read32(r))
4867         }
4868         {
4869                 p := &(*(*(struct {
4870                         DefaultAccel, AirAccel, FastAccel,
4871                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4872                         Fluidity, Smoothing, Sink,
4873                         Gravity float32
4874                 }))(obj)).Gravity
4875                 *p = math.Float32frombits(read32(r))
4876         }
4877 }
4878
4879 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4880         for local146 := range (*(*(struct {
4881                 Pos, Vel, Acc  [3]float32
4882                 ExpirationTime float32 // in seconds.
4883                 Size           float32
4884                 Collide        bool
4885
4886                 //mt:len32
4887                 Texture
4888
4889                 Vertical    bool
4890                 CollisionRm bool
4891                 AnimParams  TileAnim
4892                 Glow        uint8
4893                 AOCollision bool
4894                 NodeParam0  Content
4895                 NodeParam2  uint8
4896                 NodeTile    uint8
4897         }))(obj)).Pos {
4898                 {
4899                         x := ((*(*(struct {
4900                                 Pos, Vel, Acc  [3]float32
4901                                 ExpirationTime float32 // in seconds.
4902                                 Size           float32
4903                                 Collide        bool
4904
4905                                 //mt:len32
4906                                 Texture
4907
4908                                 Vertical    bool
4909                                 CollisionRm bool
4910                                 AnimParams  TileAnim
4911                                 Glow        uint8
4912                                 AOCollision bool
4913                                 NodeParam0  Content
4914                                 NodeParam2  uint8
4915                                 NodeTile    uint8
4916                         }))(obj)).Pos)[local146]
4917                         write32(w, math.Float32bits(x))
4918                 }
4919         }
4920         for local147 := range (*(*(struct {
4921                 Pos, Vel, Acc  [3]float32
4922                 ExpirationTime float32 // in seconds.
4923                 Size           float32
4924                 Collide        bool
4925
4926                 //mt:len32
4927                 Texture
4928
4929                 Vertical    bool
4930                 CollisionRm bool
4931                 AnimParams  TileAnim
4932                 Glow        uint8
4933                 AOCollision bool
4934                 NodeParam0  Content
4935                 NodeParam2  uint8
4936                 NodeTile    uint8
4937         }))(obj)).Vel {
4938                 {
4939                         x := ((*(*(struct {
4940                                 Pos, Vel, Acc  [3]float32
4941                                 ExpirationTime float32 // in seconds.
4942                                 Size           float32
4943                                 Collide        bool
4944
4945                                 //mt:len32
4946                                 Texture
4947
4948                                 Vertical    bool
4949                                 CollisionRm bool
4950                                 AnimParams  TileAnim
4951                                 Glow        uint8
4952                                 AOCollision bool
4953                                 NodeParam0  Content
4954                                 NodeParam2  uint8
4955                                 NodeTile    uint8
4956                         }))(obj)).Vel)[local147]
4957                         write32(w, math.Float32bits(x))
4958                 }
4959         }
4960         for local148 := range (*(*(struct {
4961                 Pos, Vel, Acc  [3]float32
4962                 ExpirationTime float32 // in seconds.
4963                 Size           float32
4964                 Collide        bool
4965
4966                 //mt:len32
4967                 Texture
4968
4969                 Vertical    bool
4970                 CollisionRm bool
4971                 AnimParams  TileAnim
4972                 Glow        uint8
4973                 AOCollision bool
4974                 NodeParam0  Content
4975                 NodeParam2  uint8
4976                 NodeTile    uint8
4977         }))(obj)).Acc {
4978                 {
4979                         x := ((*(*(struct {
4980                                 Pos, Vel, Acc  [3]float32
4981                                 ExpirationTime float32 // in seconds.
4982                                 Size           float32
4983                                 Collide        bool
4984
4985                                 //mt:len32
4986                                 Texture
4987
4988                                 Vertical    bool
4989                                 CollisionRm bool
4990                                 AnimParams  TileAnim
4991                                 Glow        uint8
4992                                 AOCollision bool
4993                                 NodeParam0  Content
4994                                 NodeParam2  uint8
4995                                 NodeTile    uint8
4996                         }))(obj)).Acc)[local148]
4997                         write32(w, math.Float32bits(x))
4998                 }
4999         }
5000         {
5001                 x := (*(*(struct {
5002                         Pos, Vel, Acc  [3]float32
5003                         ExpirationTime float32 // in seconds.
5004                         Size           float32
5005                         Collide        bool
5006
5007                         //mt:len32
5008                         Texture
5009
5010                         Vertical    bool
5011                         CollisionRm bool
5012                         AnimParams  TileAnim
5013                         Glow        uint8
5014                         AOCollision bool
5015                         NodeParam0  Content
5016                         NodeParam2  uint8
5017                         NodeTile    uint8
5018                 }))(obj)).ExpirationTime
5019                 write32(w, math.Float32bits(x))
5020         }
5021         {
5022                 x := (*(*(struct {
5023                         Pos, Vel, Acc  [3]float32
5024                         ExpirationTime float32 // in seconds.
5025                         Size           float32
5026                         Collide        bool
5027
5028                         //mt:len32
5029                         Texture
5030
5031                         Vertical    bool
5032                         CollisionRm bool
5033                         AnimParams  TileAnim
5034                         Glow        uint8
5035                         AOCollision bool
5036                         NodeParam0  Content
5037                         NodeParam2  uint8
5038                         NodeTile    uint8
5039                 }))(obj)).Size
5040                 write32(w, math.Float32bits(x))
5041         }
5042         {
5043                 x := (*(*(struct {
5044                         Pos, Vel, Acc  [3]float32
5045                         ExpirationTime float32 // in seconds.
5046                         Size           float32
5047                         Collide        bool
5048
5049                         //mt:len32
5050                         Texture
5051
5052                         Vertical    bool
5053                         CollisionRm bool
5054                         AnimParams  TileAnim
5055                         Glow        uint8
5056                         AOCollision bool
5057                         NodeParam0  Content
5058                         NodeParam2  uint8
5059                         NodeTile    uint8
5060                 }))(obj)).Collide
5061                 if x {
5062                         write8(w, 1)
5063                 } else {
5064                         write8(w, 0)
5065                 }
5066         }
5067         if len(([]byte(*(*string)(&((*(*(struct {
5068                 Pos, Vel, Acc  [3]float32
5069                 ExpirationTime float32 // in seconds.
5070                 Size           float32
5071                 Collide        bool
5072
5073                 //mt:len32
5074                 Texture
5075
5076                 Vertical    bool
5077                 CollisionRm bool
5078                 AnimParams  TileAnim
5079                 Glow        uint8
5080                 AOCollision bool
5081                 NodeParam0  Content
5082                 NodeParam2  uint8
5083                 NodeTile    uint8
5084         }))(obj)).Texture))))) > math.MaxUint32 {
5085                 chk(ErrTooLong)
5086         }
5087         {
5088                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5089                         Pos, Vel, Acc  [3]float32
5090                         ExpirationTime float32 // in seconds.
5091                         Size           float32
5092                         Collide        bool
5093
5094                         //mt:len32
5095                         Texture
5096
5097                         Vertical    bool
5098                         CollisionRm bool
5099                         AnimParams  TileAnim
5100                         Glow        uint8
5101                         AOCollision bool
5102                         NodeParam0  Content
5103                         NodeParam2  uint8
5104                         NodeTile    uint8
5105                 }))(obj)).Texture))))))
5106                 write32(w, uint32(x))
5107         }
5108         {
5109                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5110                         Pos, Vel, Acc  [3]float32
5111                         ExpirationTime float32 // in seconds.
5112                         Size           float32
5113                         Collide        bool
5114
5115                         //mt:len32
5116                         Texture
5117
5118                         Vertical    bool
5119                         CollisionRm bool
5120                         AnimParams  TileAnim
5121                         Glow        uint8
5122                         AOCollision bool
5123                         NodeParam0  Content
5124                         NodeParam2  uint8
5125                         NodeTile    uint8
5126                 }))(obj)).Texture))))[:])
5127                 chk(err)
5128         }
5129         {
5130                 x := (*(*(struct {
5131                         Pos, Vel, Acc  [3]float32
5132                         ExpirationTime float32 // in seconds.
5133                         Size           float32
5134                         Collide        bool
5135
5136                         //mt:len32
5137                         Texture
5138
5139                         Vertical    bool
5140                         CollisionRm bool
5141                         AnimParams  TileAnim
5142                         Glow        uint8
5143                         AOCollision bool
5144                         NodeParam0  Content
5145                         NodeParam2  uint8
5146                         NodeTile    uint8
5147                 }))(obj)).Vertical
5148                 if x {
5149                         write8(w, 1)
5150                 } else {
5151                         write8(w, 0)
5152                 }
5153         }
5154         {
5155                 x := (*(*(struct {
5156                         Pos, Vel, Acc  [3]float32
5157                         ExpirationTime float32 // in seconds.
5158                         Size           float32
5159                         Collide        bool
5160
5161                         //mt:len32
5162                         Texture
5163
5164                         Vertical    bool
5165                         CollisionRm bool
5166                         AnimParams  TileAnim
5167                         Glow        uint8
5168                         AOCollision bool
5169                         NodeParam0  Content
5170                         NodeParam2  uint8
5171                         NodeTile    uint8
5172                 }))(obj)).CollisionRm
5173                 if x {
5174                         write8(w, 1)
5175                 } else {
5176                         write8(w, 0)
5177                 }
5178         }
5179         if err := pcall(func() {
5180                 ((*(*(struct {
5181                         Pos, Vel, Acc  [3]float32
5182                         ExpirationTime float32 // in seconds.
5183                         Size           float32
5184                         Collide        bool
5185
5186                         //mt:len32
5187                         Texture
5188
5189                         Vertical    bool
5190                         CollisionRm bool
5191                         AnimParams  TileAnim
5192                         Glow        uint8
5193                         AOCollision bool
5194                         NodeParam0  Content
5195                         NodeParam2  uint8
5196                         NodeTile    uint8
5197                 }))(obj)).AnimParams).serialize(w)
5198         }); err != nil {
5199                 if err == io.EOF {
5200                         chk(io.EOF)
5201                 }
5202                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
5203         }
5204         {
5205                 x := (*(*(struct {
5206                         Pos, Vel, Acc  [3]float32
5207                         ExpirationTime float32 // in seconds.
5208                         Size           float32
5209                         Collide        bool
5210
5211                         //mt:len32
5212                         Texture
5213
5214                         Vertical    bool
5215                         CollisionRm bool
5216                         AnimParams  TileAnim
5217                         Glow        uint8
5218                         AOCollision bool
5219                         NodeParam0  Content
5220                         NodeParam2  uint8
5221                         NodeTile    uint8
5222                 }))(obj)).Glow
5223                 write8(w, uint8(x))
5224         }
5225         {
5226                 x := (*(*(struct {
5227                         Pos, Vel, Acc  [3]float32
5228                         ExpirationTime float32 // in seconds.
5229                         Size           float32
5230                         Collide        bool
5231
5232                         //mt:len32
5233                         Texture
5234
5235                         Vertical    bool
5236                         CollisionRm bool
5237                         AnimParams  TileAnim
5238                         Glow        uint8
5239                         AOCollision bool
5240                         NodeParam0  Content
5241                         NodeParam2  uint8
5242                         NodeTile    uint8
5243                 }))(obj)).AOCollision
5244                 if x {
5245                         write8(w, 1)
5246                 } else {
5247                         write8(w, 0)
5248                 }
5249         }
5250         if err := pcall(func() {
5251                 ((*(*(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)).NodeParam0).serialize(w)
5269         }); err != nil {
5270                 if err == io.EOF {
5271                         chk(io.EOF)
5272                 }
5273                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
5274         }
5275         {
5276                 x := (*(*(struct {
5277                         Pos, Vel, Acc  [3]float32
5278                         ExpirationTime float32 // in seconds.
5279                         Size           float32
5280                         Collide        bool
5281
5282                         //mt:len32
5283                         Texture
5284
5285                         Vertical    bool
5286                         CollisionRm bool
5287                         AnimParams  TileAnim
5288                         Glow        uint8
5289                         AOCollision bool
5290                         NodeParam0  Content
5291                         NodeParam2  uint8
5292                         NodeTile    uint8
5293                 }))(obj)).NodeParam2
5294                 write8(w, uint8(x))
5295         }
5296         {
5297                 x := (*(*(struct {
5298                         Pos, Vel, Acc  [3]float32
5299                         ExpirationTime float32 // in seconds.
5300                         Size           float32
5301                         Collide        bool
5302
5303                         //mt:len32
5304                         Texture
5305
5306                         Vertical    bool
5307                         CollisionRm bool
5308                         AnimParams  TileAnim
5309                         Glow        uint8
5310                         AOCollision bool
5311                         NodeParam0  Content
5312                         NodeParam2  uint8
5313                         NodeTile    uint8
5314                 }))(obj)).NodeTile
5315                 write8(w, uint8(x))
5316         }
5317 }
5318
5319 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5320         for local149 := range (*(*(struct {
5321                 Pos, Vel, Acc  [3]float32
5322                 ExpirationTime float32 // in seconds.
5323                 Size           float32
5324                 Collide        bool
5325
5326                 //mt:len32
5327                 Texture
5328
5329                 Vertical    bool
5330                 CollisionRm bool
5331                 AnimParams  TileAnim
5332                 Glow        uint8
5333                 AOCollision bool
5334                 NodeParam0  Content
5335                 NodeParam2  uint8
5336                 NodeTile    uint8
5337         }))(obj)).Pos {
5338                 {
5339                         p := &((*(*(struct {
5340                                 Pos, Vel, Acc  [3]float32
5341                                 ExpirationTime float32 // in seconds.
5342                                 Size           float32
5343                                 Collide        bool
5344
5345                                 //mt:len32
5346                                 Texture
5347
5348                                 Vertical    bool
5349                                 CollisionRm bool
5350                                 AnimParams  TileAnim
5351                                 Glow        uint8
5352                                 AOCollision bool
5353                                 NodeParam0  Content
5354                                 NodeParam2  uint8
5355                                 NodeTile    uint8
5356                         }))(obj)).Pos)[local149]
5357                         *p = math.Float32frombits(read32(r))
5358                 }
5359         }
5360         for local150 := range (*(*(struct {
5361                 Pos, Vel, Acc  [3]float32
5362                 ExpirationTime float32 // in seconds.
5363                 Size           float32
5364                 Collide        bool
5365
5366                 //mt:len32
5367                 Texture
5368
5369                 Vertical    bool
5370                 CollisionRm bool
5371                 AnimParams  TileAnim
5372                 Glow        uint8
5373                 AOCollision bool
5374                 NodeParam0  Content
5375                 NodeParam2  uint8
5376                 NodeTile    uint8
5377         }))(obj)).Vel {
5378                 {
5379                         p := &((*(*(struct {
5380                                 Pos, Vel, Acc  [3]float32
5381                                 ExpirationTime float32 // in seconds.
5382                                 Size           float32
5383                                 Collide        bool
5384
5385                                 //mt:len32
5386                                 Texture
5387
5388                                 Vertical    bool
5389                                 CollisionRm bool
5390                                 AnimParams  TileAnim
5391                                 Glow        uint8
5392                                 AOCollision bool
5393                                 NodeParam0  Content
5394                                 NodeParam2  uint8
5395                                 NodeTile    uint8
5396                         }))(obj)).Vel)[local150]
5397                         *p = math.Float32frombits(read32(r))
5398                 }
5399         }
5400         for local151 := range (*(*(struct {
5401                 Pos, Vel, Acc  [3]float32
5402                 ExpirationTime float32 // in seconds.
5403                 Size           float32
5404                 Collide        bool
5405
5406                 //mt:len32
5407                 Texture
5408
5409                 Vertical    bool
5410                 CollisionRm bool
5411                 AnimParams  TileAnim
5412                 Glow        uint8
5413                 AOCollision bool
5414                 NodeParam0  Content
5415                 NodeParam2  uint8
5416                 NodeTile    uint8
5417         }))(obj)).Acc {
5418                 {
5419                         p := &((*(*(struct {
5420                                 Pos, Vel, Acc  [3]float32
5421                                 ExpirationTime float32 // in seconds.
5422                                 Size           float32
5423                                 Collide        bool
5424
5425                                 //mt:len32
5426                                 Texture
5427
5428                                 Vertical    bool
5429                                 CollisionRm bool
5430                                 AnimParams  TileAnim
5431                                 Glow        uint8
5432                                 AOCollision bool
5433                                 NodeParam0  Content
5434                                 NodeParam2  uint8
5435                                 NodeTile    uint8
5436                         }))(obj)).Acc)[local151]
5437                         *p = math.Float32frombits(read32(r))
5438                 }
5439         }
5440         {
5441                 p := &(*(*(struct {
5442                         Pos, Vel, Acc  [3]float32
5443                         ExpirationTime float32 // in seconds.
5444                         Size           float32
5445                         Collide        bool
5446
5447                         //mt:len32
5448                         Texture
5449
5450                         Vertical    bool
5451                         CollisionRm bool
5452                         AnimParams  TileAnim
5453                         Glow        uint8
5454                         AOCollision bool
5455                         NodeParam0  Content
5456                         NodeParam2  uint8
5457                         NodeTile    uint8
5458                 }))(obj)).ExpirationTime
5459                 *p = math.Float32frombits(read32(r))
5460         }
5461         {
5462                 p := &(*(*(struct {
5463                         Pos, Vel, Acc  [3]float32
5464                         ExpirationTime float32 // in seconds.
5465                         Size           float32
5466                         Collide        bool
5467
5468                         //mt:len32
5469                         Texture
5470
5471                         Vertical    bool
5472                         CollisionRm bool
5473                         AnimParams  TileAnim
5474                         Glow        uint8
5475                         AOCollision bool
5476                         NodeParam0  Content
5477                         NodeParam2  uint8
5478                         NodeTile    uint8
5479                 }))(obj)).Size
5480                 *p = math.Float32frombits(read32(r))
5481         }
5482         {
5483                 p := &(*(*(struct {
5484                         Pos, Vel, Acc  [3]float32
5485                         ExpirationTime float32 // in seconds.
5486                         Size           float32
5487                         Collide        bool
5488
5489                         //mt:len32
5490                         Texture
5491
5492                         Vertical    bool
5493                         CollisionRm bool
5494                         AnimParams  TileAnim
5495                         Glow        uint8
5496                         AOCollision bool
5497                         NodeParam0  Content
5498                         NodeParam2  uint8
5499                         NodeTile    uint8
5500                 }))(obj)).Collide
5501                 switch n := read8(r); n {
5502                 case 0:
5503                         *p = false
5504                 case 1:
5505                         *p = true
5506                 default:
5507                         chk(fmt.Errorf("invalid bool: %d", n))
5508                 }
5509         }
5510         var local152 []uint8
5511         var local153 uint32
5512         {
5513                 p := &local153
5514                 *p = read32(r)
5515         }
5516         (local152) = make([]uint8, local153)
5517         {
5518                 _, err := io.ReadFull(r, (local152)[:])
5519                 chk(err)
5520         }
5521         (*(*string)(&((*(*(struct {
5522                 Pos, Vel, Acc  [3]float32
5523                 ExpirationTime float32 // in seconds.
5524                 Size           float32
5525                 Collide        bool
5526
5527                 //mt:len32
5528                 Texture
5529
5530                 Vertical    bool
5531                 CollisionRm bool
5532                 AnimParams  TileAnim
5533                 Glow        uint8
5534                 AOCollision bool
5535                 NodeParam0  Content
5536                 NodeParam2  uint8
5537                 NodeTile    uint8
5538         }))(obj)).Texture))) = string(local152)
5539         {
5540                 p := &(*(*(struct {
5541                         Pos, Vel, Acc  [3]float32
5542                         ExpirationTime float32 // in seconds.
5543                         Size           float32
5544                         Collide        bool
5545
5546                         //mt:len32
5547                         Texture
5548
5549                         Vertical    bool
5550                         CollisionRm bool
5551                         AnimParams  TileAnim
5552                         Glow        uint8
5553                         AOCollision bool
5554                         NodeParam0  Content
5555                         NodeParam2  uint8
5556                         NodeTile    uint8
5557                 }))(obj)).Vertical
5558                 switch n := read8(r); n {
5559                 case 0:
5560                         *p = false
5561                 case 1:
5562                         *p = true
5563                 default:
5564                         chk(fmt.Errorf("invalid bool: %d", n))
5565                 }
5566         }
5567         {
5568                 p := &(*(*(struct {
5569                         Pos, Vel, Acc  [3]float32
5570                         ExpirationTime float32 // in seconds.
5571                         Size           float32
5572                         Collide        bool
5573
5574                         //mt:len32
5575                         Texture
5576
5577                         Vertical    bool
5578                         CollisionRm bool
5579                         AnimParams  TileAnim
5580                         Glow        uint8
5581                         AOCollision bool
5582                         NodeParam0  Content
5583                         NodeParam2  uint8
5584                         NodeTile    uint8
5585                 }))(obj)).CollisionRm
5586                 switch n := read8(r); n {
5587                 case 0:
5588                         *p = false
5589                 case 1:
5590                         *p = true
5591                 default:
5592                         chk(fmt.Errorf("invalid bool: %d", n))
5593                 }
5594         }
5595         if err := pcall(func() {
5596                 ((*(*(struct {
5597                         Pos, Vel, Acc  [3]float32
5598                         ExpirationTime float32 // in seconds.
5599                         Size           float32
5600                         Collide        bool
5601
5602                         //mt:len32
5603                         Texture
5604
5605                         Vertical    bool
5606                         CollisionRm bool
5607                         AnimParams  TileAnim
5608                         Glow        uint8
5609                         AOCollision bool
5610                         NodeParam0  Content
5611                         NodeParam2  uint8
5612                         NodeTile    uint8
5613                 }))(obj)).AnimParams).deserialize(r)
5614         }); err != nil {
5615                 if err == io.EOF {
5616                         chk(io.EOF)
5617                 }
5618                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
5619         }
5620         {
5621                 p := &(*(*(struct {
5622                         Pos, Vel, Acc  [3]float32
5623                         ExpirationTime float32 // in seconds.
5624                         Size           float32
5625                         Collide        bool
5626
5627                         //mt:len32
5628                         Texture
5629
5630                         Vertical    bool
5631                         CollisionRm bool
5632                         AnimParams  TileAnim
5633                         Glow        uint8
5634                         AOCollision bool
5635                         NodeParam0  Content
5636                         NodeParam2  uint8
5637                         NodeTile    uint8
5638                 }))(obj)).Glow
5639                 *p = read8(r)
5640         }
5641         {
5642                 p := &(*(*(struct {
5643                         Pos, Vel, Acc  [3]float32
5644                         ExpirationTime float32 // in seconds.
5645                         Size           float32
5646                         Collide        bool
5647
5648                         //mt:len32
5649                         Texture
5650
5651                         Vertical    bool
5652                         CollisionRm bool
5653                         AnimParams  TileAnim
5654                         Glow        uint8
5655                         AOCollision bool
5656                         NodeParam0  Content
5657                         NodeParam2  uint8
5658                         NodeTile    uint8
5659                 }))(obj)).AOCollision
5660                 switch n := read8(r); n {
5661                 case 0:
5662                         *p = false
5663                 case 1:
5664                         *p = true
5665                 default:
5666                         chk(fmt.Errorf("invalid bool: %d", n))
5667                 }
5668         }
5669         if err := pcall(func() {
5670                 ((*(*(struct {
5671                         Pos, Vel, Acc  [3]float32
5672                         ExpirationTime float32 // in seconds.
5673                         Size           float32
5674                         Collide        bool
5675
5676                         //mt:len32
5677                         Texture
5678
5679                         Vertical    bool
5680                         CollisionRm bool
5681                         AnimParams  TileAnim
5682                         Glow        uint8
5683                         AOCollision bool
5684                         NodeParam0  Content
5685                         NodeParam2  uint8
5686                         NodeTile    uint8
5687                 }))(obj)).NodeParam0).deserialize(r)
5688         }); err != nil {
5689                 if err == io.EOF {
5690                         chk(io.EOF)
5691                 }
5692                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
5693         }
5694         {
5695                 p := &(*(*(struct {
5696                         Pos, Vel, Acc  [3]float32
5697                         ExpirationTime float32 // in seconds.
5698                         Size           float32
5699                         Collide        bool
5700
5701                         //mt:len32
5702                         Texture
5703
5704                         Vertical    bool
5705                         CollisionRm bool
5706                         AnimParams  TileAnim
5707                         Glow        uint8
5708                         AOCollision bool
5709                         NodeParam0  Content
5710                         NodeParam2  uint8
5711                         NodeTile    uint8
5712                 }))(obj)).NodeParam2
5713                 *p = read8(r)
5714         }
5715         {
5716                 p := &(*(*(struct {
5717                         Pos, Vel, Acc  [3]float32
5718                         ExpirationTime float32 // in seconds.
5719                         Size           float32
5720                         Collide        bool
5721
5722                         //mt:len32
5723                         Texture
5724
5725                         Vertical    bool
5726                         CollisionRm bool
5727                         AnimParams  TileAnim
5728                         Glow        uint8
5729                         AOCollision bool
5730                         NodeParam0  Content
5731                         NodeParam2  uint8
5732                         NodeTile    uint8
5733                 }))(obj)).NodeTile
5734                 *p = read8(r)
5735         }
5736 }
5737
5738 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5739         {
5740                 x := (*(*(struct {
5741                         Amount         uint16
5742                         Duration       float32
5743                         Pos, Vel, Acc  [2][3]float32
5744                         ExpirationTime [2]float32 // in seconds.
5745                         Size           [2]float32
5746                         Collide        bool
5747
5748                         //mt:len32
5749                         Texture
5750
5751                         ID           ParticleSpawnerID
5752                         Vertical     bool
5753                         CollisionRm  bool
5754                         AttachedAOID AOID
5755                         AnimParams   TileAnim
5756                         Glow         uint8
5757                         AOCollision  bool
5758                         NodeParam0   Content
5759                         NodeParam2   uint8
5760                         NodeTile     uint8
5761                 }))(obj)).Amount
5762                 write16(w, uint16(x))
5763         }
5764         {
5765                 x := (*(*(struct {
5766                         Amount         uint16
5767                         Duration       float32
5768                         Pos, Vel, Acc  [2][3]float32
5769                         ExpirationTime [2]float32 // in seconds.
5770                         Size           [2]float32
5771                         Collide        bool
5772
5773                         //mt:len32
5774                         Texture
5775
5776                         ID           ParticleSpawnerID
5777                         Vertical     bool
5778                         CollisionRm  bool
5779                         AttachedAOID AOID
5780                         AnimParams   TileAnim
5781                         Glow         uint8
5782                         AOCollision  bool
5783                         NodeParam0   Content
5784                         NodeParam2   uint8
5785                         NodeTile     uint8
5786                 }))(obj)).Duration
5787                 write32(w, math.Float32bits(x))
5788         }
5789         for local154 := range (*(*(struct {
5790                 Amount         uint16
5791                 Duration       float32
5792                 Pos, Vel, Acc  [2][3]float32
5793                 ExpirationTime [2]float32 // in seconds.
5794                 Size           [2]float32
5795                 Collide        bool
5796
5797                 //mt:len32
5798                 Texture
5799
5800                 ID           ParticleSpawnerID
5801                 Vertical     bool
5802                 CollisionRm  bool
5803                 AttachedAOID AOID
5804                 AnimParams   TileAnim
5805                 Glow         uint8
5806                 AOCollision  bool
5807                 NodeParam0   Content
5808                 NodeParam2   uint8
5809                 NodeTile     uint8
5810         }))(obj)).Pos {
5811                 for local155 := range ((*(*(struct {
5812                         Amount         uint16
5813                         Duration       float32
5814                         Pos, Vel, Acc  [2][3]float32
5815                         ExpirationTime [2]float32 // in seconds.
5816                         Size           [2]float32
5817                         Collide        bool
5818
5819                         //mt:len32
5820                         Texture
5821
5822                         ID           ParticleSpawnerID
5823                         Vertical     bool
5824                         CollisionRm  bool
5825                         AttachedAOID AOID
5826                         AnimParams   TileAnim
5827                         Glow         uint8
5828                         AOCollision  bool
5829                         NodeParam0   Content
5830                         NodeParam2   uint8
5831                         NodeTile     uint8
5832                 }))(obj)).Pos)[local154] {
5833                         {
5834                                 x := (((*(*(struct {
5835                                         Amount         uint16
5836                                         Duration       float32
5837                                         Pos, Vel, Acc  [2][3]float32
5838                                         ExpirationTime [2]float32 // in seconds.
5839                                         Size           [2]float32
5840                                         Collide        bool
5841
5842                                         //mt:len32
5843                                         Texture
5844
5845                                         ID           ParticleSpawnerID
5846                                         Vertical     bool
5847                                         CollisionRm  bool
5848                                         AttachedAOID AOID
5849                                         AnimParams   TileAnim
5850                                         Glow         uint8
5851                                         AOCollision  bool
5852                                         NodeParam0   Content
5853                                         NodeParam2   uint8
5854                                         NodeTile     uint8
5855                                 }))(obj)).Pos)[local154])[local155]
5856                                 write32(w, math.Float32bits(x))
5857                         }
5858                 }
5859         }
5860         for local156 := range (*(*(struct {
5861                 Amount         uint16
5862                 Duration       float32
5863                 Pos, Vel, Acc  [2][3]float32
5864                 ExpirationTime [2]float32 // in seconds.
5865                 Size           [2]float32
5866                 Collide        bool
5867
5868                 //mt:len32
5869                 Texture
5870
5871                 ID           ParticleSpawnerID
5872                 Vertical     bool
5873                 CollisionRm  bool
5874                 AttachedAOID AOID
5875                 AnimParams   TileAnim
5876                 Glow         uint8
5877                 AOCollision  bool
5878                 NodeParam0   Content
5879                 NodeParam2   uint8
5880                 NodeTile     uint8
5881         }))(obj)).Vel {
5882                 for local157 := range ((*(*(struct {
5883                         Amount         uint16
5884                         Duration       float32
5885                         Pos, Vel, Acc  [2][3]float32
5886                         ExpirationTime [2]float32 // in seconds.
5887                         Size           [2]float32
5888                         Collide        bool
5889
5890                         //mt:len32
5891                         Texture
5892
5893                         ID           ParticleSpawnerID
5894                         Vertical     bool
5895                         CollisionRm  bool
5896                         AttachedAOID AOID
5897                         AnimParams   TileAnim
5898                         Glow         uint8
5899                         AOCollision  bool
5900                         NodeParam0   Content
5901                         NodeParam2   uint8
5902                         NodeTile     uint8
5903                 }))(obj)).Vel)[local156] {
5904                         {
5905                                 x := (((*(*(struct {
5906                                         Amount         uint16
5907                                         Duration       float32
5908                                         Pos, Vel, Acc  [2][3]float32
5909                                         ExpirationTime [2]float32 // in seconds.
5910                                         Size           [2]float32
5911                                         Collide        bool
5912
5913                                         //mt:len32
5914                                         Texture
5915
5916                                         ID           ParticleSpawnerID
5917                                         Vertical     bool
5918                                         CollisionRm  bool
5919                                         AttachedAOID AOID
5920                                         AnimParams   TileAnim
5921                                         Glow         uint8
5922                                         AOCollision  bool
5923                                         NodeParam0   Content
5924                                         NodeParam2   uint8
5925                                         NodeTile     uint8
5926                                 }))(obj)).Vel)[local156])[local157]
5927                                 write32(w, math.Float32bits(x))
5928                         }
5929                 }
5930         }
5931         for local158 := range (*(*(struct {
5932                 Amount         uint16
5933                 Duration       float32
5934                 Pos, Vel, Acc  [2][3]float32
5935                 ExpirationTime [2]float32 // in seconds.
5936                 Size           [2]float32
5937                 Collide        bool
5938
5939                 //mt:len32
5940                 Texture
5941
5942                 ID           ParticleSpawnerID
5943                 Vertical     bool
5944                 CollisionRm  bool
5945                 AttachedAOID AOID
5946                 AnimParams   TileAnim
5947                 Glow         uint8
5948                 AOCollision  bool
5949                 NodeParam0   Content
5950                 NodeParam2   uint8
5951                 NodeTile     uint8
5952         }))(obj)).Acc {
5953                 for local159 := range ((*(*(struct {
5954                         Amount         uint16
5955                         Duration       float32
5956                         Pos, Vel, Acc  [2][3]float32
5957                         ExpirationTime [2]float32 // in seconds.
5958                         Size           [2]float32
5959                         Collide        bool
5960
5961                         //mt:len32
5962                         Texture
5963
5964                         ID           ParticleSpawnerID
5965                         Vertical     bool
5966                         CollisionRm  bool
5967                         AttachedAOID AOID
5968                         AnimParams   TileAnim
5969                         Glow         uint8
5970                         AOCollision  bool
5971                         NodeParam0   Content
5972                         NodeParam2   uint8
5973                         NodeTile     uint8
5974                 }))(obj)).Acc)[local158] {
5975                         {
5976                                 x := (((*(*(struct {
5977                                         Amount         uint16
5978                                         Duration       float32
5979                                         Pos, Vel, Acc  [2][3]float32
5980                                         ExpirationTime [2]float32 // in seconds.
5981                                         Size           [2]float32
5982                                         Collide        bool
5983
5984                                         //mt:len32
5985                                         Texture
5986
5987                                         ID           ParticleSpawnerID
5988                                         Vertical     bool
5989                                         CollisionRm  bool
5990                                         AttachedAOID AOID
5991                                         AnimParams   TileAnim
5992                                         Glow         uint8
5993                                         AOCollision  bool
5994                                         NodeParam0   Content
5995                                         NodeParam2   uint8
5996                                         NodeTile     uint8
5997                                 }))(obj)).Acc)[local158])[local159]
5998                                 write32(w, math.Float32bits(x))
5999                         }
6000                 }
6001         }
6002         for local160 := range (*(*(struct {
6003                 Amount         uint16
6004                 Duration       float32
6005                 Pos, Vel, Acc  [2][3]float32
6006                 ExpirationTime [2]float32 // in seconds.
6007                 Size           [2]float32
6008                 Collide        bool
6009
6010                 //mt:len32
6011                 Texture
6012
6013                 ID           ParticleSpawnerID
6014                 Vertical     bool
6015                 CollisionRm  bool
6016                 AttachedAOID AOID
6017                 AnimParams   TileAnim
6018                 Glow         uint8
6019                 AOCollision  bool
6020                 NodeParam0   Content
6021                 NodeParam2   uint8
6022                 NodeTile     uint8
6023         }))(obj)).ExpirationTime {
6024                 {
6025                         x := ((*(*(struct {
6026                                 Amount         uint16
6027                                 Duration       float32
6028                                 Pos, Vel, Acc  [2][3]float32
6029                                 ExpirationTime [2]float32 // in seconds.
6030                                 Size           [2]float32
6031                                 Collide        bool
6032
6033                                 //mt:len32
6034                                 Texture
6035
6036                                 ID           ParticleSpawnerID
6037                                 Vertical     bool
6038                                 CollisionRm  bool
6039                                 AttachedAOID AOID
6040                                 AnimParams   TileAnim
6041                                 Glow         uint8
6042                                 AOCollision  bool
6043                                 NodeParam0   Content
6044                                 NodeParam2   uint8
6045                                 NodeTile     uint8
6046                         }))(obj)).ExpirationTime)[local160]
6047                         write32(w, math.Float32bits(x))
6048                 }
6049         }
6050         for local161 := range (*(*(struct {
6051                 Amount         uint16
6052                 Duration       float32
6053                 Pos, Vel, Acc  [2][3]float32
6054                 ExpirationTime [2]float32 // in seconds.
6055                 Size           [2]float32
6056                 Collide        bool
6057
6058                 //mt:len32
6059                 Texture
6060
6061                 ID           ParticleSpawnerID
6062                 Vertical     bool
6063                 CollisionRm  bool
6064                 AttachedAOID AOID
6065                 AnimParams   TileAnim
6066                 Glow         uint8
6067                 AOCollision  bool
6068                 NodeParam0   Content
6069                 NodeParam2   uint8
6070                 NodeTile     uint8
6071         }))(obj)).Size {
6072                 {
6073                         x := ((*(*(struct {
6074                                 Amount         uint16
6075                                 Duration       float32
6076                                 Pos, Vel, Acc  [2][3]float32
6077                                 ExpirationTime [2]float32 // in seconds.
6078                                 Size           [2]float32
6079                                 Collide        bool
6080
6081                                 //mt:len32
6082                                 Texture
6083
6084                                 ID           ParticleSpawnerID
6085                                 Vertical     bool
6086                                 CollisionRm  bool
6087                                 AttachedAOID AOID
6088                                 AnimParams   TileAnim
6089                                 Glow         uint8
6090                                 AOCollision  bool
6091                                 NodeParam0   Content
6092                                 NodeParam2   uint8
6093                                 NodeTile     uint8
6094                         }))(obj)).Size)[local161]
6095                         write32(w, math.Float32bits(x))
6096                 }
6097         }
6098         {
6099                 x := (*(*(struct {
6100                         Amount         uint16
6101                         Duration       float32
6102                         Pos, Vel, Acc  [2][3]float32
6103                         ExpirationTime [2]float32 // in seconds.
6104                         Size           [2]float32
6105                         Collide        bool
6106
6107                         //mt:len32
6108                         Texture
6109
6110                         ID           ParticleSpawnerID
6111                         Vertical     bool
6112                         CollisionRm  bool
6113                         AttachedAOID AOID
6114                         AnimParams   TileAnim
6115                         Glow         uint8
6116                         AOCollision  bool
6117                         NodeParam0   Content
6118                         NodeParam2   uint8
6119                         NodeTile     uint8
6120                 }))(obj)).Collide
6121                 if x {
6122                         write8(w, 1)
6123                 } else {
6124                         write8(w, 0)
6125                 }
6126         }
6127         if len(([]byte(*(*string)(&((*(*(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)).Texture))))) > math.MaxUint32 {
6149                 chk(ErrTooLong)
6150         }
6151         {
6152                 x := uint32(len(([]byte(*(*string)(&((*(*(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)).Texture))))))
6174                 write32(w, uint32(x))
6175         }
6176         {
6177                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6178                         Amount         uint16
6179                         Duration       float32
6180                         Pos, Vel, Acc  [2][3]float32
6181                         ExpirationTime [2]float32 // in seconds.
6182                         Size           [2]float32
6183                         Collide        bool
6184
6185                         //mt:len32
6186                         Texture
6187
6188                         ID           ParticleSpawnerID
6189                         Vertical     bool
6190                         CollisionRm  bool
6191                         AttachedAOID AOID
6192                         AnimParams   TileAnim
6193                         Glow         uint8
6194                         AOCollision  bool
6195                         NodeParam0   Content
6196                         NodeParam2   uint8
6197                         NodeTile     uint8
6198                 }))(obj)).Texture))))[:])
6199                 chk(err)
6200         }
6201         if err := pcall(func() {
6202                 ((*(*(struct {
6203                         Amount         uint16
6204                         Duration       float32
6205                         Pos, Vel, Acc  [2][3]float32
6206                         ExpirationTime [2]float32 // in seconds.
6207                         Size           [2]float32
6208                         Collide        bool
6209
6210                         //mt:len32
6211                         Texture
6212
6213                         ID           ParticleSpawnerID
6214                         Vertical     bool
6215                         CollisionRm  bool
6216                         AttachedAOID AOID
6217                         AnimParams   TileAnim
6218                         Glow         uint8
6219                         AOCollision  bool
6220                         NodeParam0   Content
6221                         NodeParam2   uint8
6222                         NodeTile     uint8
6223                 }))(obj)).ID).serialize(w)
6224         }); err != nil {
6225                 if err == io.EOF {
6226                         chk(io.EOF)
6227                 }
6228                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
6229         }
6230         {
6231                 x := (*(*(struct {
6232                         Amount         uint16
6233                         Duration       float32
6234                         Pos, Vel, Acc  [2][3]float32
6235                         ExpirationTime [2]float32 // in seconds.
6236                         Size           [2]float32
6237                         Collide        bool
6238
6239                         //mt:len32
6240                         Texture
6241
6242                         ID           ParticleSpawnerID
6243                         Vertical     bool
6244                         CollisionRm  bool
6245                         AttachedAOID AOID
6246                         AnimParams   TileAnim
6247                         Glow         uint8
6248                         AOCollision  bool
6249                         NodeParam0   Content
6250                         NodeParam2   uint8
6251                         NodeTile     uint8
6252                 }))(obj)).Vertical
6253                 if x {
6254                         write8(w, 1)
6255                 } else {
6256                         write8(w, 0)
6257                 }
6258         }
6259         {
6260                 x := (*(*(struct {
6261                         Amount         uint16
6262                         Duration       float32
6263                         Pos, Vel, Acc  [2][3]float32
6264                         ExpirationTime [2]float32 // in seconds.
6265                         Size           [2]float32
6266                         Collide        bool
6267
6268                         //mt:len32
6269                         Texture
6270
6271                         ID           ParticleSpawnerID
6272                         Vertical     bool
6273                         CollisionRm  bool
6274                         AttachedAOID AOID
6275                         AnimParams   TileAnim
6276                         Glow         uint8
6277                         AOCollision  bool
6278                         NodeParam0   Content
6279                         NodeParam2   uint8
6280                         NodeTile     uint8
6281                 }))(obj)).CollisionRm
6282                 if x {
6283                         write8(w, 1)
6284                 } else {
6285                         write8(w, 0)
6286                 }
6287         }
6288         if err := pcall(func() {
6289                 ((*(*(struct {
6290                         Amount         uint16
6291                         Duration       float32
6292                         Pos, Vel, Acc  [2][3]float32
6293                         ExpirationTime [2]float32 // in seconds.
6294                         Size           [2]float32
6295                         Collide        bool
6296
6297                         //mt:len32
6298                         Texture
6299
6300                         ID           ParticleSpawnerID
6301                         Vertical     bool
6302                         CollisionRm  bool
6303                         AttachedAOID AOID
6304                         AnimParams   TileAnim
6305                         Glow         uint8
6306                         AOCollision  bool
6307                         NodeParam0   Content
6308                         NodeParam2   uint8
6309                         NodeTile     uint8
6310                 }))(obj)).AttachedAOID).serialize(w)
6311         }); err != nil {
6312                 if err == io.EOF {
6313                         chk(io.EOF)
6314                 }
6315                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
6316         }
6317         if err := pcall(func() {
6318                 ((*(*(struct {
6319                         Amount         uint16
6320                         Duration       float32
6321                         Pos, Vel, Acc  [2][3]float32
6322                         ExpirationTime [2]float32 // in seconds.
6323                         Size           [2]float32
6324                         Collide        bool
6325
6326                         //mt:len32
6327                         Texture
6328
6329                         ID           ParticleSpawnerID
6330                         Vertical     bool
6331                         CollisionRm  bool
6332                         AttachedAOID AOID
6333                         AnimParams   TileAnim
6334                         Glow         uint8
6335                         AOCollision  bool
6336                         NodeParam0   Content
6337                         NodeParam2   uint8
6338                         NodeTile     uint8
6339                 }))(obj)).AnimParams).serialize(w)
6340         }); err != nil {
6341                 if err == io.EOF {
6342                         chk(io.EOF)
6343                 }
6344                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
6345         }
6346         {
6347                 x := (*(*(struct {
6348                         Amount         uint16
6349                         Duration       float32
6350                         Pos, Vel, Acc  [2][3]float32
6351                         ExpirationTime [2]float32 // in seconds.
6352                         Size           [2]float32
6353                         Collide        bool
6354
6355                         //mt:len32
6356                         Texture
6357
6358                         ID           ParticleSpawnerID
6359                         Vertical     bool
6360                         CollisionRm  bool
6361                         AttachedAOID AOID
6362                         AnimParams   TileAnim
6363                         Glow         uint8
6364                         AOCollision  bool
6365                         NodeParam0   Content
6366                         NodeParam2   uint8
6367                         NodeTile     uint8
6368                 }))(obj)).Glow
6369                 write8(w, uint8(x))
6370         }
6371         {
6372                 x := (*(*(struct {
6373                         Amount         uint16
6374                         Duration       float32
6375                         Pos, Vel, Acc  [2][3]float32
6376                         ExpirationTime [2]float32 // in seconds.
6377                         Size           [2]float32
6378                         Collide        bool
6379
6380                         //mt:len32
6381                         Texture
6382
6383                         ID           ParticleSpawnerID
6384                         Vertical     bool
6385                         CollisionRm  bool
6386                         AttachedAOID AOID
6387                         AnimParams   TileAnim
6388                         Glow         uint8
6389                         AOCollision  bool
6390                         NodeParam0   Content
6391                         NodeParam2   uint8
6392                         NodeTile     uint8
6393                 }))(obj)).AOCollision
6394                 if x {
6395                         write8(w, 1)
6396                 } else {
6397                         write8(w, 0)
6398                 }
6399         }
6400         if err := pcall(func() {
6401                 ((*(*(struct {
6402                         Amount         uint16
6403                         Duration       float32
6404                         Pos, Vel, Acc  [2][3]float32
6405                         ExpirationTime [2]float32 // in seconds.
6406                         Size           [2]float32
6407                         Collide        bool
6408
6409                         //mt:len32
6410                         Texture
6411
6412                         ID           ParticleSpawnerID
6413                         Vertical     bool
6414                         CollisionRm  bool
6415                         AttachedAOID AOID
6416                         AnimParams   TileAnim
6417                         Glow         uint8
6418                         AOCollision  bool
6419                         NodeParam0   Content
6420                         NodeParam2   uint8
6421                         NodeTile     uint8
6422                 }))(obj)).NodeParam0).serialize(w)
6423         }); err != nil {
6424                 if err == io.EOF {
6425                         chk(io.EOF)
6426                 }
6427                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
6428         }
6429         {
6430                 x := (*(*(struct {
6431                         Amount         uint16
6432                         Duration       float32
6433                         Pos, Vel, Acc  [2][3]float32
6434                         ExpirationTime [2]float32 // in seconds.
6435                         Size           [2]float32
6436                         Collide        bool
6437
6438                         //mt:len32
6439                         Texture
6440
6441                         ID           ParticleSpawnerID
6442                         Vertical     bool
6443                         CollisionRm  bool
6444                         AttachedAOID AOID
6445                         AnimParams   TileAnim
6446                         Glow         uint8
6447                         AOCollision  bool
6448                         NodeParam0   Content
6449                         NodeParam2   uint8
6450                         NodeTile     uint8
6451                 }))(obj)).NodeParam2
6452                 write8(w, uint8(x))
6453         }
6454         {
6455                 x := (*(*(struct {
6456                         Amount         uint16
6457                         Duration       float32
6458                         Pos, Vel, Acc  [2][3]float32
6459                         ExpirationTime [2]float32 // in seconds.
6460                         Size           [2]float32
6461                         Collide        bool
6462
6463                         //mt:len32
6464                         Texture
6465
6466                         ID           ParticleSpawnerID
6467                         Vertical     bool
6468                         CollisionRm  bool
6469                         AttachedAOID AOID
6470                         AnimParams   TileAnim
6471                         Glow         uint8
6472                         AOCollision  bool
6473                         NodeParam0   Content
6474                         NodeParam2   uint8
6475                         NodeTile     uint8
6476                 }))(obj)).NodeTile
6477                 write8(w, uint8(x))
6478         }
6479 }
6480
6481 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6482         {
6483                 p := &(*(*(struct {
6484                         Amount         uint16
6485                         Duration       float32
6486                         Pos, Vel, Acc  [2][3]float32
6487                         ExpirationTime [2]float32 // in seconds.
6488                         Size           [2]float32
6489                         Collide        bool
6490
6491                         //mt:len32
6492                         Texture
6493
6494                         ID           ParticleSpawnerID
6495                         Vertical     bool
6496                         CollisionRm  bool
6497                         AttachedAOID AOID
6498                         AnimParams   TileAnim
6499                         Glow         uint8
6500                         AOCollision  bool
6501                         NodeParam0   Content
6502                         NodeParam2   uint8
6503                         NodeTile     uint8
6504                 }))(obj)).Amount
6505                 *p = read16(r)
6506         }
6507         {
6508                 p := &(*(*(struct {
6509                         Amount         uint16
6510                         Duration       float32
6511                         Pos, Vel, Acc  [2][3]float32
6512                         ExpirationTime [2]float32 // in seconds.
6513                         Size           [2]float32
6514                         Collide        bool
6515
6516                         //mt:len32
6517                         Texture
6518
6519                         ID           ParticleSpawnerID
6520                         Vertical     bool
6521                         CollisionRm  bool
6522                         AttachedAOID AOID
6523                         AnimParams   TileAnim
6524                         Glow         uint8
6525                         AOCollision  bool
6526                         NodeParam0   Content
6527                         NodeParam2   uint8
6528                         NodeTile     uint8
6529                 }))(obj)).Duration
6530                 *p = math.Float32frombits(read32(r))
6531         }
6532         for local162 := range (*(*(struct {
6533                 Amount         uint16
6534                 Duration       float32
6535                 Pos, Vel, Acc  [2][3]float32
6536                 ExpirationTime [2]float32 // in seconds.
6537                 Size           [2]float32
6538                 Collide        bool
6539
6540                 //mt:len32
6541                 Texture
6542
6543                 ID           ParticleSpawnerID
6544                 Vertical     bool
6545                 CollisionRm  bool
6546                 AttachedAOID AOID
6547                 AnimParams   TileAnim
6548                 Glow         uint8
6549                 AOCollision  bool
6550                 NodeParam0   Content
6551                 NodeParam2   uint8
6552                 NodeTile     uint8
6553         }))(obj)).Pos {
6554                 for local163 := range ((*(*(struct {
6555                         Amount         uint16
6556                         Duration       float32
6557                         Pos, Vel, Acc  [2][3]float32
6558                         ExpirationTime [2]float32 // in seconds.
6559                         Size           [2]float32
6560                         Collide        bool
6561
6562                         //mt:len32
6563                         Texture
6564
6565                         ID           ParticleSpawnerID
6566                         Vertical     bool
6567                         CollisionRm  bool
6568                         AttachedAOID AOID
6569                         AnimParams   TileAnim
6570                         Glow         uint8
6571                         AOCollision  bool
6572                         NodeParam0   Content
6573                         NodeParam2   uint8
6574                         NodeTile     uint8
6575                 }))(obj)).Pos)[local162] {
6576                         {
6577                                 p := &(((*(*(struct {
6578                                         Amount         uint16
6579                                         Duration       float32
6580                                         Pos, Vel, Acc  [2][3]float32
6581                                         ExpirationTime [2]float32 // in seconds.
6582                                         Size           [2]float32
6583                                         Collide        bool
6584
6585                                         //mt:len32
6586                                         Texture
6587
6588                                         ID           ParticleSpawnerID
6589                                         Vertical     bool
6590                                         CollisionRm  bool
6591                                         AttachedAOID AOID
6592                                         AnimParams   TileAnim
6593                                         Glow         uint8
6594                                         AOCollision  bool
6595                                         NodeParam0   Content
6596                                         NodeParam2   uint8
6597                                         NodeTile     uint8
6598                                 }))(obj)).Pos)[local162])[local163]
6599                                 *p = math.Float32frombits(read32(r))
6600                         }
6601                 }
6602         }
6603         for local164 := range (*(*(struct {
6604                 Amount         uint16
6605                 Duration       float32
6606                 Pos, Vel, Acc  [2][3]float32
6607                 ExpirationTime [2]float32 // in seconds.
6608                 Size           [2]float32
6609                 Collide        bool
6610
6611                 //mt:len32
6612                 Texture
6613
6614                 ID           ParticleSpawnerID
6615                 Vertical     bool
6616                 CollisionRm  bool
6617                 AttachedAOID AOID
6618                 AnimParams   TileAnim
6619                 Glow         uint8
6620                 AOCollision  bool
6621                 NodeParam0   Content
6622                 NodeParam2   uint8
6623                 NodeTile     uint8
6624         }))(obj)).Vel {
6625                 for local165 := range ((*(*(struct {
6626                         Amount         uint16
6627                         Duration       float32
6628                         Pos, Vel, Acc  [2][3]float32
6629                         ExpirationTime [2]float32 // in seconds.
6630                         Size           [2]float32
6631                         Collide        bool
6632
6633                         //mt:len32
6634                         Texture
6635
6636                         ID           ParticleSpawnerID
6637                         Vertical     bool
6638                         CollisionRm  bool
6639                         AttachedAOID AOID
6640                         AnimParams   TileAnim
6641                         Glow         uint8
6642                         AOCollision  bool
6643                         NodeParam0   Content
6644                         NodeParam2   uint8
6645                         NodeTile     uint8
6646                 }))(obj)).Vel)[local164] {
6647                         {
6648                                 p := &(((*(*(struct {
6649                                         Amount         uint16
6650                                         Duration       float32
6651                                         Pos, Vel, Acc  [2][3]float32
6652                                         ExpirationTime [2]float32 // in seconds.
6653                                         Size           [2]float32
6654                                         Collide        bool
6655
6656                                         //mt:len32
6657                                         Texture
6658
6659                                         ID           ParticleSpawnerID
6660                                         Vertical     bool
6661                                         CollisionRm  bool
6662                                         AttachedAOID AOID
6663                                         AnimParams   TileAnim
6664                                         Glow         uint8
6665                                         AOCollision  bool
6666                                         NodeParam0   Content
6667                                         NodeParam2   uint8
6668                                         NodeTile     uint8
6669                                 }))(obj)).Vel)[local164])[local165]
6670                                 *p = math.Float32frombits(read32(r))
6671                         }
6672                 }
6673         }
6674         for local166 := range (*(*(struct {
6675                 Amount         uint16
6676                 Duration       float32
6677                 Pos, Vel, Acc  [2][3]float32
6678                 ExpirationTime [2]float32 // in seconds.
6679                 Size           [2]float32
6680                 Collide        bool
6681
6682                 //mt:len32
6683                 Texture
6684
6685                 ID           ParticleSpawnerID
6686                 Vertical     bool
6687                 CollisionRm  bool
6688                 AttachedAOID AOID
6689                 AnimParams   TileAnim
6690                 Glow         uint8
6691                 AOCollision  bool
6692                 NodeParam0   Content
6693                 NodeParam2   uint8
6694                 NodeTile     uint8
6695         }))(obj)).Acc {
6696                 for local167 := range ((*(*(struct {
6697                         Amount         uint16
6698                         Duration       float32
6699                         Pos, Vel, Acc  [2][3]float32
6700                         ExpirationTime [2]float32 // in seconds.
6701                         Size           [2]float32
6702                         Collide        bool
6703
6704                         //mt:len32
6705                         Texture
6706
6707                         ID           ParticleSpawnerID
6708                         Vertical     bool
6709                         CollisionRm  bool
6710                         AttachedAOID AOID
6711                         AnimParams   TileAnim
6712                         Glow         uint8
6713                         AOCollision  bool
6714                         NodeParam0   Content
6715                         NodeParam2   uint8
6716                         NodeTile     uint8
6717                 }))(obj)).Acc)[local166] {
6718                         {
6719                                 p := &(((*(*(struct {
6720                                         Amount         uint16
6721                                         Duration       float32
6722                                         Pos, Vel, Acc  [2][3]float32
6723                                         ExpirationTime [2]float32 // in seconds.
6724                                         Size           [2]float32
6725                                         Collide        bool
6726
6727                                         //mt:len32
6728                                         Texture
6729
6730                                         ID           ParticleSpawnerID
6731                                         Vertical     bool
6732                                         CollisionRm  bool
6733                                         AttachedAOID AOID
6734                                         AnimParams   TileAnim
6735                                         Glow         uint8
6736                                         AOCollision  bool
6737                                         NodeParam0   Content
6738                                         NodeParam2   uint8
6739                                         NodeTile     uint8
6740                                 }))(obj)).Acc)[local166])[local167]
6741                                 *p = math.Float32frombits(read32(r))
6742                         }
6743                 }
6744         }
6745         for local168 := range (*(*(struct {
6746                 Amount         uint16
6747                 Duration       float32
6748                 Pos, Vel, Acc  [2][3]float32
6749                 ExpirationTime [2]float32 // in seconds.
6750                 Size           [2]float32
6751                 Collide        bool
6752
6753                 //mt:len32
6754                 Texture
6755
6756                 ID           ParticleSpawnerID
6757                 Vertical     bool
6758                 CollisionRm  bool
6759                 AttachedAOID AOID
6760                 AnimParams   TileAnim
6761                 Glow         uint8
6762                 AOCollision  bool
6763                 NodeParam0   Content
6764                 NodeParam2   uint8
6765                 NodeTile     uint8
6766         }))(obj)).ExpirationTime {
6767                 {
6768                         p := &((*(*(struct {
6769                                 Amount         uint16
6770                                 Duration       float32
6771                                 Pos, Vel, Acc  [2][3]float32
6772                                 ExpirationTime [2]float32 // in seconds.
6773                                 Size           [2]float32
6774                                 Collide        bool
6775
6776                                 //mt:len32
6777                                 Texture
6778
6779                                 ID           ParticleSpawnerID
6780                                 Vertical     bool
6781                                 CollisionRm  bool
6782                                 AttachedAOID AOID
6783                                 AnimParams   TileAnim
6784                                 Glow         uint8
6785                                 AOCollision  bool
6786                                 NodeParam0   Content
6787                                 NodeParam2   uint8
6788                                 NodeTile     uint8
6789                         }))(obj)).ExpirationTime)[local168]
6790                         *p = math.Float32frombits(read32(r))
6791                 }
6792         }
6793         for local169 := range (*(*(struct {
6794                 Amount         uint16
6795                 Duration       float32
6796                 Pos, Vel, Acc  [2][3]float32
6797                 ExpirationTime [2]float32 // in seconds.
6798                 Size           [2]float32
6799                 Collide        bool
6800
6801                 //mt:len32
6802                 Texture
6803
6804                 ID           ParticleSpawnerID
6805                 Vertical     bool
6806                 CollisionRm  bool
6807                 AttachedAOID AOID
6808                 AnimParams   TileAnim
6809                 Glow         uint8
6810                 AOCollision  bool
6811                 NodeParam0   Content
6812                 NodeParam2   uint8
6813                 NodeTile     uint8
6814         }))(obj)).Size {
6815                 {
6816                         p := &((*(*(struct {
6817                                 Amount         uint16
6818                                 Duration       float32
6819                                 Pos, Vel, Acc  [2][3]float32
6820                                 ExpirationTime [2]float32 // in seconds.
6821                                 Size           [2]float32
6822                                 Collide        bool
6823
6824                                 //mt:len32
6825                                 Texture
6826
6827                                 ID           ParticleSpawnerID
6828                                 Vertical     bool
6829                                 CollisionRm  bool
6830                                 AttachedAOID AOID
6831                                 AnimParams   TileAnim
6832                                 Glow         uint8
6833                                 AOCollision  bool
6834                                 NodeParam0   Content
6835                                 NodeParam2   uint8
6836                                 NodeTile     uint8
6837                         }))(obj)).Size)[local169]
6838                         *p = math.Float32frombits(read32(r))
6839                 }
6840         }
6841         {
6842                 p := &(*(*(struct {
6843                         Amount         uint16
6844                         Duration       float32
6845                         Pos, Vel, Acc  [2][3]float32
6846                         ExpirationTime [2]float32 // in seconds.
6847                         Size           [2]float32
6848                         Collide        bool
6849
6850                         //mt:len32
6851                         Texture
6852
6853                         ID           ParticleSpawnerID
6854                         Vertical     bool
6855                         CollisionRm  bool
6856                         AttachedAOID AOID
6857                         AnimParams   TileAnim
6858                         Glow         uint8
6859                         AOCollision  bool
6860                         NodeParam0   Content
6861                         NodeParam2   uint8
6862                         NodeTile     uint8
6863                 }))(obj)).Collide
6864                 switch n := read8(r); n {
6865                 case 0:
6866                         *p = false
6867                 case 1:
6868                         *p = true
6869                 default:
6870                         chk(fmt.Errorf("invalid bool: %d", n))
6871                 }
6872         }
6873         var local170 []uint8
6874         var local171 uint32
6875         {
6876                 p := &local171
6877                 *p = read32(r)
6878         }
6879         (local170) = make([]uint8, local171)
6880         {
6881                 _, err := io.ReadFull(r, (local170)[:])
6882                 chk(err)
6883         }
6884         (*(*string)(&((*(*(struct {
6885                 Amount         uint16
6886                 Duration       float32
6887                 Pos, Vel, Acc  [2][3]float32
6888                 ExpirationTime [2]float32 // in seconds.
6889                 Size           [2]float32
6890                 Collide        bool
6891
6892                 //mt:len32
6893                 Texture
6894
6895                 ID           ParticleSpawnerID
6896                 Vertical     bool
6897                 CollisionRm  bool
6898                 AttachedAOID AOID
6899                 AnimParams   TileAnim
6900                 Glow         uint8
6901                 AOCollision  bool
6902                 NodeParam0   Content
6903                 NodeParam2   uint8
6904                 NodeTile     uint8
6905         }))(obj)).Texture))) = string(local170)
6906         if err := pcall(func() {
6907                 ((*(*(struct {
6908                         Amount         uint16
6909                         Duration       float32
6910                         Pos, Vel, Acc  [2][3]float32
6911                         ExpirationTime [2]float32 // in seconds.
6912                         Size           [2]float32
6913                         Collide        bool
6914
6915                         //mt:len32
6916                         Texture
6917
6918                         ID           ParticleSpawnerID
6919                         Vertical     bool
6920                         CollisionRm  bool
6921                         AttachedAOID AOID
6922                         AnimParams   TileAnim
6923                         Glow         uint8
6924                         AOCollision  bool
6925                         NodeParam0   Content
6926                         NodeParam2   uint8
6927                         NodeTile     uint8
6928                 }))(obj)).ID).deserialize(r)
6929         }); err != nil {
6930                 if err == io.EOF {
6931                         chk(io.EOF)
6932                 }
6933                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
6934         }
6935         {
6936                 p := &(*(*(struct {
6937                         Amount         uint16
6938                         Duration       float32
6939                         Pos, Vel, Acc  [2][3]float32
6940                         ExpirationTime [2]float32 // in seconds.
6941                         Size           [2]float32
6942                         Collide        bool
6943
6944                         //mt:len32
6945                         Texture
6946
6947                         ID           ParticleSpawnerID
6948                         Vertical     bool
6949                         CollisionRm  bool
6950                         AttachedAOID AOID
6951                         AnimParams   TileAnim
6952                         Glow         uint8
6953                         AOCollision  bool
6954                         NodeParam0   Content
6955                         NodeParam2   uint8
6956                         NodeTile     uint8
6957                 }))(obj)).Vertical
6958                 switch n := read8(r); n {
6959                 case 0:
6960                         *p = false
6961                 case 1:
6962                         *p = true
6963                 default:
6964                         chk(fmt.Errorf("invalid bool: %d", n))
6965                 }
6966         }
6967         {
6968                 p := &(*(*(struct {
6969                         Amount         uint16
6970                         Duration       float32
6971                         Pos, Vel, Acc  [2][3]float32
6972                         ExpirationTime [2]float32 // in seconds.
6973                         Size           [2]float32
6974                         Collide        bool
6975
6976                         //mt:len32
6977                         Texture
6978
6979                         ID           ParticleSpawnerID
6980                         Vertical     bool
6981                         CollisionRm  bool
6982                         AttachedAOID AOID
6983                         AnimParams   TileAnim
6984                         Glow         uint8
6985                         AOCollision  bool
6986                         NodeParam0   Content
6987                         NodeParam2   uint8
6988                         NodeTile     uint8
6989                 }))(obj)).CollisionRm
6990                 switch n := read8(r); n {
6991                 case 0:
6992                         *p = false
6993                 case 1:
6994                         *p = true
6995                 default:
6996                         chk(fmt.Errorf("invalid bool: %d", n))
6997                 }
6998         }
6999         if err := pcall(func() {
7000                 ((*(*(struct {
7001                         Amount         uint16
7002                         Duration       float32
7003                         Pos, Vel, Acc  [2][3]float32
7004                         ExpirationTime [2]float32 // in seconds.
7005                         Size           [2]float32
7006                         Collide        bool
7007
7008                         //mt:len32
7009                         Texture
7010
7011                         ID           ParticleSpawnerID
7012                         Vertical     bool
7013                         CollisionRm  bool
7014                         AttachedAOID AOID
7015                         AnimParams   TileAnim
7016                         Glow         uint8
7017                         AOCollision  bool
7018                         NodeParam0   Content
7019                         NodeParam2   uint8
7020                         NodeTile     uint8
7021                 }))(obj)).AttachedAOID).deserialize(r)
7022         }); err != nil {
7023                 if err == io.EOF {
7024                         chk(io.EOF)
7025                 }
7026                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
7027         }
7028         if err := pcall(func() {
7029                 ((*(*(struct {
7030                         Amount         uint16
7031                         Duration       float32
7032                         Pos, Vel, Acc  [2][3]float32
7033                         ExpirationTime [2]float32 // in seconds.
7034                         Size           [2]float32
7035                         Collide        bool
7036
7037                         //mt:len32
7038                         Texture
7039
7040                         ID           ParticleSpawnerID
7041                         Vertical     bool
7042                         CollisionRm  bool
7043                         AttachedAOID AOID
7044                         AnimParams   TileAnim
7045                         Glow         uint8
7046                         AOCollision  bool
7047                         NodeParam0   Content
7048                         NodeParam2   uint8
7049                         NodeTile     uint8
7050                 }))(obj)).AnimParams).deserialize(r)
7051         }); err != nil {
7052                 if err == io.EOF {
7053                         chk(io.EOF)
7054                 }
7055                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
7056         }
7057         {
7058                 p := &(*(*(struct {
7059                         Amount         uint16
7060                         Duration       float32
7061                         Pos, Vel, Acc  [2][3]float32
7062                         ExpirationTime [2]float32 // in seconds.
7063                         Size           [2]float32
7064                         Collide        bool
7065
7066                         //mt:len32
7067                         Texture
7068
7069                         ID           ParticleSpawnerID
7070                         Vertical     bool
7071                         CollisionRm  bool
7072                         AttachedAOID AOID
7073                         AnimParams   TileAnim
7074                         Glow         uint8
7075                         AOCollision  bool
7076                         NodeParam0   Content
7077                         NodeParam2   uint8
7078                         NodeTile     uint8
7079                 }))(obj)).Glow
7080                 *p = read8(r)
7081         }
7082         {
7083                 p := &(*(*(struct {
7084                         Amount         uint16
7085                         Duration       float32
7086                         Pos, Vel, Acc  [2][3]float32
7087                         ExpirationTime [2]float32 // in seconds.
7088                         Size           [2]float32
7089                         Collide        bool
7090
7091                         //mt:len32
7092                         Texture
7093
7094                         ID           ParticleSpawnerID
7095                         Vertical     bool
7096                         CollisionRm  bool
7097                         AttachedAOID AOID
7098                         AnimParams   TileAnim
7099                         Glow         uint8
7100                         AOCollision  bool
7101                         NodeParam0   Content
7102                         NodeParam2   uint8
7103                         NodeTile     uint8
7104                 }))(obj)).AOCollision
7105                 switch n := read8(r); n {
7106                 case 0:
7107                         *p = false
7108                 case 1:
7109                         *p = true
7110                 default:
7111                         chk(fmt.Errorf("invalid bool: %d", n))
7112                 }
7113         }
7114         if err := pcall(func() {
7115                 ((*(*(struct {
7116                         Amount         uint16
7117                         Duration       float32
7118                         Pos, Vel, Acc  [2][3]float32
7119                         ExpirationTime [2]float32 // in seconds.
7120                         Size           [2]float32
7121                         Collide        bool
7122
7123                         //mt:len32
7124                         Texture
7125
7126                         ID           ParticleSpawnerID
7127                         Vertical     bool
7128                         CollisionRm  bool
7129                         AttachedAOID AOID
7130                         AnimParams   TileAnim
7131                         Glow         uint8
7132                         AOCollision  bool
7133                         NodeParam0   Content
7134                         NodeParam2   uint8
7135                         NodeTile     uint8
7136                 }))(obj)).NodeParam0).deserialize(r)
7137         }); err != nil {
7138                 if err == io.EOF {
7139                         chk(io.EOF)
7140                 }
7141                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
7142         }
7143         {
7144                 p := &(*(*(struct {
7145                         Amount         uint16
7146                         Duration       float32
7147                         Pos, Vel, Acc  [2][3]float32
7148                         ExpirationTime [2]float32 // in seconds.
7149                         Size           [2]float32
7150                         Collide        bool
7151
7152                         //mt:len32
7153                         Texture
7154
7155                         ID           ParticleSpawnerID
7156                         Vertical     bool
7157                         CollisionRm  bool
7158                         AttachedAOID AOID
7159                         AnimParams   TileAnim
7160                         Glow         uint8
7161                         AOCollision  bool
7162                         NodeParam0   Content
7163                         NodeParam2   uint8
7164                         NodeTile     uint8
7165                 }))(obj)).NodeParam2
7166                 *p = read8(r)
7167         }
7168         {
7169                 p := &(*(*(struct {
7170                         Amount         uint16
7171                         Duration       float32
7172                         Pos, Vel, Acc  [2][3]float32
7173                         ExpirationTime [2]float32 // in seconds.
7174                         Size           [2]float32
7175                         Collide        bool
7176
7177                         //mt:len32
7178                         Texture
7179
7180                         ID           ParticleSpawnerID
7181                         Vertical     bool
7182                         CollisionRm  bool
7183                         AttachedAOID AOID
7184                         AnimParams   TileAnim
7185                         Glow         uint8
7186                         AOCollision  bool
7187                         NodeParam0   Content
7188                         NodeParam2   uint8
7189                         NodeTile     uint8
7190                 }))(obj)).NodeTile
7191                 *p = read8(r)
7192         }
7193 }
7194
7195 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7196         if err := pcall(func() {
7197                 ((*(*(struct {
7198                         ID HUDID
7199                         HUD
7200                 }))(obj)).ID).serialize(w)
7201         }); err != nil {
7202                 if err == io.EOF {
7203                         chk(io.EOF)
7204                 }
7205                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7206         }
7207         if err := pcall(func() {
7208                 ((*(*(struct {
7209                         ID HUDID
7210                         HUD
7211                 }))(obj)).HUD).serialize(w)
7212         }); err != nil {
7213                 if err == io.EOF {
7214                         chk(io.EOF)
7215                 }
7216                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUD", err))
7217         }
7218 }
7219
7220 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7221         if err := pcall(func() {
7222                 ((*(*(struct {
7223                         ID HUDID
7224                         HUD
7225                 }))(obj)).ID).deserialize(r)
7226         }); err != nil {
7227                 if err == io.EOF {
7228                         chk(io.EOF)
7229                 }
7230                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7231         }
7232         if err := pcall(func() {
7233                 ((*(*(struct {
7234                         ID HUDID
7235                         HUD
7236                 }))(obj)).HUD).deserialize(r)
7237         }); err != nil {
7238                 if err == io.EOF {
7239                         chk(io.EOF)
7240                 }
7241                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUD", err))
7242         }
7243 }
7244
7245 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7246         if err := pcall(func() {
7247                 ((*(*(struct {
7248                         ID HUDID
7249                 }))(obj)).ID).serialize(w)
7250         }); err != nil {
7251                 if err == io.EOF {
7252                         chk(io.EOF)
7253                 }
7254                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7255         }
7256 }
7257
7258 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7259         if err := pcall(func() {
7260                 ((*(*(struct {
7261                         ID HUDID
7262                 }))(obj)).ID).deserialize(r)
7263         }); err != nil {
7264                 if err == io.EOF {
7265                         chk(io.EOF)
7266                 }
7267                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7268         }
7269 }
7270
7271 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7272         if err := pcall(func() {
7273                 ((*(*(struct {
7274                         ID HUDID
7275
7276                         Field HUDField
7277
7278                         //mt:if %s.Field == HUDPos
7279                         Pos [2]float32
7280
7281                         //mt:if %s.Field == HUDName
7282                         Name string
7283
7284                         //mt:if %s.Field == HUDScale
7285                         Scale [2]float32
7286
7287                         //mt:if %s.Field == HUDText
7288                         Text string
7289
7290                         //mt:if %s.Field == HUDNumber
7291                         Number uint32
7292
7293                         //mt:if %s.Field == HUDItem
7294                         Item uint32
7295
7296                         //mt:if %s.Field == HUDDir
7297                         Dir uint32
7298
7299                         //mt:if %s.Field == HUDAlign
7300                         Align [2]float32
7301
7302                         //mt:if %s.Field == HUDOffset
7303                         Offset [2]float32
7304
7305                         //mt:if %s.Field == HUDWorldPos
7306                         WorldPos Pos
7307
7308                         //mt:if %s.Field == HUDSize
7309                         Size [2]int32
7310
7311                         //mt:if %s.Field == HUDZIndex
7312                         ZIndex int32
7313
7314                         //mt:if %s.Field == HUDText2
7315                         Text2 string
7316                 }))(obj)).ID).serialize(w)
7317         }); err != nil {
7318                 if err == io.EOF {
7319                         chk(io.EOF)
7320                 }
7321                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7322         }
7323         if err := pcall(func() {
7324                 ((*(*(struct {
7325                         ID HUDID
7326
7327                         Field HUDField
7328
7329                         //mt:if %s.Field == HUDPos
7330                         Pos [2]float32
7331
7332                         //mt:if %s.Field == HUDName
7333                         Name string
7334
7335                         //mt:if %s.Field == HUDScale
7336                         Scale [2]float32
7337
7338                         //mt:if %s.Field == HUDText
7339                         Text string
7340
7341                         //mt:if %s.Field == HUDNumber
7342                         Number uint32
7343
7344                         //mt:if %s.Field == HUDItem
7345                         Item uint32
7346
7347                         //mt:if %s.Field == HUDDir
7348                         Dir uint32
7349
7350                         //mt:if %s.Field == HUDAlign
7351                         Align [2]float32
7352
7353                         //mt:if %s.Field == HUDOffset
7354                         Offset [2]float32
7355
7356                         //mt:if %s.Field == HUDWorldPos
7357                         WorldPos Pos
7358
7359                         //mt:if %s.Field == HUDSize
7360                         Size [2]int32
7361
7362                         //mt:if %s.Field == HUDZIndex
7363                         ZIndex int32
7364
7365                         //mt:if %s.Field == HUDText2
7366                         Text2 string
7367                 }))(obj)).Field).serialize(w)
7368         }); err != nil {
7369                 if err == io.EOF {
7370                         chk(io.EOF)
7371                 }
7372                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDField", err))
7373         }
7374         if !((*(*(struct {
7375                 ID HUDID
7376
7377                 Field HUDField
7378
7379                 //mt:if %s.Field == HUDPos
7380                 Pos [2]float32
7381
7382                 //mt:if %s.Field == HUDName
7383                 Name string
7384
7385                 //mt:if %s.Field == HUDScale
7386                 Scale [2]float32
7387
7388                 //mt:if %s.Field == HUDText
7389                 Text string
7390
7391                 //mt:if %s.Field == HUDNumber
7392                 Number uint32
7393
7394                 //mt:if %s.Field == HUDItem
7395                 Item uint32
7396
7397                 //mt:if %s.Field == HUDDir
7398                 Dir uint32
7399
7400                 //mt:if %s.Field == HUDAlign
7401                 Align [2]float32
7402
7403                 //mt:if %s.Field == HUDOffset
7404                 Offset [2]float32
7405
7406                 //mt:if %s.Field == HUDWorldPos
7407                 WorldPos Pos
7408
7409                 //mt:if %s.Field == HUDSize
7410                 Size [2]int32
7411
7412                 //mt:if %s.Field == HUDZIndex
7413                 ZIndex int32
7414
7415                 //mt:if %s.Field == HUDText2
7416                 Text2 string
7417         }))(obj)).Field < hudMax) {
7418                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7419         }
7420         if (*(*(struct {
7421                 ID HUDID
7422
7423                 Field HUDField
7424
7425                 //mt:if %s.Field == HUDPos
7426                 Pos [2]float32
7427
7428                 //mt:if %s.Field == HUDName
7429                 Name string
7430
7431                 //mt:if %s.Field == HUDScale
7432                 Scale [2]float32
7433
7434                 //mt:if %s.Field == HUDText
7435                 Text string
7436
7437                 //mt:if %s.Field == HUDNumber
7438                 Number uint32
7439
7440                 //mt:if %s.Field == HUDItem
7441                 Item uint32
7442
7443                 //mt:if %s.Field == HUDDir
7444                 Dir uint32
7445
7446                 //mt:if %s.Field == HUDAlign
7447                 Align [2]float32
7448
7449                 //mt:if %s.Field == HUDOffset
7450                 Offset [2]float32
7451
7452                 //mt:if %s.Field == HUDWorldPos
7453                 WorldPos Pos
7454
7455                 //mt:if %s.Field == HUDSize
7456                 Size [2]int32
7457
7458                 //mt:if %s.Field == HUDZIndex
7459                 ZIndex int32
7460
7461                 //mt:if %s.Field == HUDText2
7462                 Text2 string
7463         }))(obj)).Field == HUDPos {
7464                 for local172 := range (*(*(struct {
7465                         ID HUDID
7466
7467                         Field HUDField
7468
7469                         //mt:if %s.Field == HUDPos
7470                         Pos [2]float32
7471
7472                         //mt:if %s.Field == HUDName
7473                         Name string
7474
7475                         //mt:if %s.Field == HUDScale
7476                         Scale [2]float32
7477
7478                         //mt:if %s.Field == HUDText
7479                         Text string
7480
7481                         //mt:if %s.Field == HUDNumber
7482                         Number uint32
7483
7484                         //mt:if %s.Field == HUDItem
7485                         Item uint32
7486
7487                         //mt:if %s.Field == HUDDir
7488                         Dir uint32
7489
7490                         //mt:if %s.Field == HUDAlign
7491                         Align [2]float32
7492
7493                         //mt:if %s.Field == HUDOffset
7494                         Offset [2]float32
7495
7496                         //mt:if %s.Field == HUDWorldPos
7497                         WorldPos Pos
7498
7499                         //mt:if %s.Field == HUDSize
7500                         Size [2]int32
7501
7502                         //mt:if %s.Field == HUDZIndex
7503                         ZIndex int32
7504
7505                         //mt:if %s.Field == HUDText2
7506                         Text2 string
7507                 }))(obj)).Pos {
7508                         {
7509                                 x := ((*(*(struct {
7510                                         ID HUDID
7511
7512                                         Field HUDField
7513
7514                                         //mt:if %s.Field == HUDPos
7515                                         Pos [2]float32
7516
7517                                         //mt:if %s.Field == HUDName
7518                                         Name string
7519
7520                                         //mt:if %s.Field == HUDScale
7521                                         Scale [2]float32
7522
7523                                         //mt:if %s.Field == HUDText
7524                                         Text string
7525
7526                                         //mt:if %s.Field == HUDNumber
7527                                         Number uint32
7528
7529                                         //mt:if %s.Field == HUDItem
7530                                         Item uint32
7531
7532                                         //mt:if %s.Field == HUDDir
7533                                         Dir uint32
7534
7535                                         //mt:if %s.Field == HUDAlign
7536                                         Align [2]float32
7537
7538                                         //mt:if %s.Field == HUDOffset
7539                                         Offset [2]float32
7540
7541                                         //mt:if %s.Field == HUDWorldPos
7542                                         WorldPos Pos
7543
7544                                         //mt:if %s.Field == HUDSize
7545                                         Size [2]int32
7546
7547                                         //mt:if %s.Field == HUDZIndex
7548                                         ZIndex int32
7549
7550                                         //mt:if %s.Field == HUDText2
7551                                         Text2 string
7552                                 }))(obj)).Pos)[local172]
7553                                 write32(w, math.Float32bits(x))
7554                         }
7555                 }
7556         }
7557         if (*(*(struct {
7558                 ID HUDID
7559
7560                 Field HUDField
7561
7562                 //mt:if %s.Field == HUDPos
7563                 Pos [2]float32
7564
7565                 //mt:if %s.Field == HUDName
7566                 Name string
7567
7568                 //mt:if %s.Field == HUDScale
7569                 Scale [2]float32
7570
7571                 //mt:if %s.Field == HUDText
7572                 Text string
7573
7574                 //mt:if %s.Field == HUDNumber
7575                 Number uint32
7576
7577                 //mt:if %s.Field == HUDItem
7578                 Item uint32
7579
7580                 //mt:if %s.Field == HUDDir
7581                 Dir uint32
7582
7583                 //mt:if %s.Field == HUDAlign
7584                 Align [2]float32
7585
7586                 //mt:if %s.Field == HUDOffset
7587                 Offset [2]float32
7588
7589                 //mt:if %s.Field == HUDWorldPos
7590                 WorldPos Pos
7591
7592                 //mt:if %s.Field == HUDSize
7593                 Size [2]int32
7594
7595                 //mt:if %s.Field == HUDZIndex
7596                 ZIndex int32
7597
7598                 //mt:if %s.Field == HUDText2
7599                 Text2 string
7600         }))(obj)).Field == HUDName {
7601                 if len(([]byte((*(*(struct {
7602                         ID HUDID
7603
7604                         Field HUDField
7605
7606                         //mt:if %s.Field == HUDPos
7607                         Pos [2]float32
7608
7609                         //mt:if %s.Field == HUDName
7610                         Name string
7611
7612                         //mt:if %s.Field == HUDScale
7613                         Scale [2]float32
7614
7615                         //mt:if %s.Field == HUDText
7616                         Text string
7617
7618                         //mt:if %s.Field == HUDNumber
7619                         Number uint32
7620
7621                         //mt:if %s.Field == HUDItem
7622                         Item uint32
7623
7624                         //mt:if %s.Field == HUDDir
7625                         Dir uint32
7626
7627                         //mt:if %s.Field == HUDAlign
7628                         Align [2]float32
7629
7630                         //mt:if %s.Field == HUDOffset
7631                         Offset [2]float32
7632
7633                         //mt:if %s.Field == HUDWorldPos
7634                         WorldPos Pos
7635
7636                         //mt:if %s.Field == HUDSize
7637                         Size [2]int32
7638
7639                         //mt:if %s.Field == HUDZIndex
7640                         ZIndex int32
7641
7642                         //mt:if %s.Field == HUDText2
7643                         Text2 string
7644                 }))(obj)).Name))) > math.MaxUint16 {
7645                         chk(ErrTooLong)
7646                 }
7647                 {
7648                         x := uint16(len(([]byte((*(*(struct {
7649                                 ID HUDID
7650
7651                                 Field HUDField
7652
7653                                 //mt:if %s.Field == HUDPos
7654                                 Pos [2]float32
7655
7656                                 //mt:if %s.Field == HUDName
7657                                 Name string
7658
7659                                 //mt:if %s.Field == HUDScale
7660                                 Scale [2]float32
7661
7662                                 //mt:if %s.Field == HUDText
7663                                 Text string
7664
7665                                 //mt:if %s.Field == HUDNumber
7666                                 Number uint32
7667
7668                                 //mt:if %s.Field == HUDItem
7669                                 Item uint32
7670
7671                                 //mt:if %s.Field == HUDDir
7672                                 Dir uint32
7673
7674                                 //mt:if %s.Field == HUDAlign
7675                                 Align [2]float32
7676
7677                                 //mt:if %s.Field == HUDOffset
7678                                 Offset [2]float32
7679
7680                                 //mt:if %s.Field == HUDWorldPos
7681                                 WorldPos Pos
7682
7683                                 //mt:if %s.Field == HUDSize
7684                                 Size [2]int32
7685
7686                                 //mt:if %s.Field == HUDZIndex
7687                                 ZIndex int32
7688
7689                                 //mt:if %s.Field == HUDText2
7690                                 Text2 string
7691                         }))(obj)).Name))))
7692                         write16(w, uint16(x))
7693                 }
7694                 {
7695                         _, err := w.Write(([]byte((*(*(struct {
7696                                 ID HUDID
7697
7698                                 Field HUDField
7699
7700                                 //mt:if %s.Field == HUDPos
7701                                 Pos [2]float32
7702
7703                                 //mt:if %s.Field == HUDName
7704                                 Name string
7705
7706                                 //mt:if %s.Field == HUDScale
7707                                 Scale [2]float32
7708
7709                                 //mt:if %s.Field == HUDText
7710                                 Text string
7711
7712                                 //mt:if %s.Field == HUDNumber
7713                                 Number uint32
7714
7715                                 //mt:if %s.Field == HUDItem
7716                                 Item uint32
7717
7718                                 //mt:if %s.Field == HUDDir
7719                                 Dir uint32
7720
7721                                 //mt:if %s.Field == HUDAlign
7722                                 Align [2]float32
7723
7724                                 //mt:if %s.Field == HUDOffset
7725                                 Offset [2]float32
7726
7727                                 //mt:if %s.Field == HUDWorldPos
7728                                 WorldPos Pos
7729
7730                                 //mt:if %s.Field == HUDSize
7731                                 Size [2]int32
7732
7733                                 //mt:if %s.Field == HUDZIndex
7734                                 ZIndex int32
7735
7736                                 //mt:if %s.Field == HUDText2
7737                                 Text2 string
7738                         }))(obj)).Name))[:])
7739                         chk(err)
7740                 }
7741         }
7742         if (*(*(struct {
7743                 ID HUDID
7744
7745                 Field HUDField
7746
7747                 //mt:if %s.Field == HUDPos
7748                 Pos [2]float32
7749
7750                 //mt:if %s.Field == HUDName
7751                 Name string
7752
7753                 //mt:if %s.Field == HUDScale
7754                 Scale [2]float32
7755
7756                 //mt:if %s.Field == HUDText
7757                 Text string
7758
7759                 //mt:if %s.Field == HUDNumber
7760                 Number uint32
7761
7762                 //mt:if %s.Field == HUDItem
7763                 Item uint32
7764
7765                 //mt:if %s.Field == HUDDir
7766                 Dir uint32
7767
7768                 //mt:if %s.Field == HUDAlign
7769                 Align [2]float32
7770
7771                 //mt:if %s.Field == HUDOffset
7772                 Offset [2]float32
7773
7774                 //mt:if %s.Field == HUDWorldPos
7775                 WorldPos Pos
7776
7777                 //mt:if %s.Field == HUDSize
7778                 Size [2]int32
7779
7780                 //mt:if %s.Field == HUDZIndex
7781                 ZIndex int32
7782
7783                 //mt:if %s.Field == HUDText2
7784                 Text2 string
7785         }))(obj)).Field == HUDScale {
7786                 for local173 := range (*(*(struct {
7787                         ID HUDID
7788
7789                         Field HUDField
7790
7791                         //mt:if %s.Field == HUDPos
7792                         Pos [2]float32
7793
7794                         //mt:if %s.Field == HUDName
7795                         Name string
7796
7797                         //mt:if %s.Field == HUDScale
7798                         Scale [2]float32
7799
7800                         //mt:if %s.Field == HUDText
7801                         Text string
7802
7803                         //mt:if %s.Field == HUDNumber
7804                         Number uint32
7805
7806                         //mt:if %s.Field == HUDItem
7807                         Item uint32
7808
7809                         //mt:if %s.Field == HUDDir
7810                         Dir uint32
7811
7812                         //mt:if %s.Field == HUDAlign
7813                         Align [2]float32
7814
7815                         //mt:if %s.Field == HUDOffset
7816                         Offset [2]float32
7817
7818                         //mt:if %s.Field == HUDWorldPos
7819                         WorldPos Pos
7820
7821                         //mt:if %s.Field == HUDSize
7822                         Size [2]int32
7823
7824                         //mt:if %s.Field == HUDZIndex
7825                         ZIndex int32
7826
7827                         //mt:if %s.Field == HUDText2
7828                         Text2 string
7829                 }))(obj)).Scale {
7830                         {
7831                                 x := ((*(*(struct {
7832                                         ID HUDID
7833
7834                                         Field HUDField
7835
7836                                         //mt:if %s.Field == HUDPos
7837                                         Pos [2]float32
7838
7839                                         //mt:if %s.Field == HUDName
7840                                         Name string
7841
7842                                         //mt:if %s.Field == HUDScale
7843                                         Scale [2]float32
7844
7845                                         //mt:if %s.Field == HUDText
7846                                         Text string
7847
7848                                         //mt:if %s.Field == HUDNumber
7849                                         Number uint32
7850
7851                                         //mt:if %s.Field == HUDItem
7852                                         Item uint32
7853
7854                                         //mt:if %s.Field == HUDDir
7855                                         Dir uint32
7856
7857                                         //mt:if %s.Field == HUDAlign
7858                                         Align [2]float32
7859
7860                                         //mt:if %s.Field == HUDOffset
7861                                         Offset [2]float32
7862
7863                                         //mt:if %s.Field == HUDWorldPos
7864                                         WorldPos Pos
7865
7866                                         //mt:if %s.Field == HUDSize
7867                                         Size [2]int32
7868
7869                                         //mt:if %s.Field == HUDZIndex
7870                                         ZIndex int32
7871
7872                                         //mt:if %s.Field == HUDText2
7873                                         Text2 string
7874                                 }))(obj)).Scale)[local173]
7875                                 write32(w, math.Float32bits(x))
7876                         }
7877                 }
7878         }
7879         if (*(*(struct {
7880                 ID HUDID
7881
7882                 Field HUDField
7883
7884                 //mt:if %s.Field == HUDPos
7885                 Pos [2]float32
7886
7887                 //mt:if %s.Field == HUDName
7888                 Name string
7889
7890                 //mt:if %s.Field == HUDScale
7891                 Scale [2]float32
7892
7893                 //mt:if %s.Field == HUDText
7894                 Text string
7895
7896                 //mt:if %s.Field == HUDNumber
7897                 Number uint32
7898
7899                 //mt:if %s.Field == HUDItem
7900                 Item uint32
7901
7902                 //mt:if %s.Field == HUDDir
7903                 Dir uint32
7904
7905                 //mt:if %s.Field == HUDAlign
7906                 Align [2]float32
7907
7908                 //mt:if %s.Field == HUDOffset
7909                 Offset [2]float32
7910
7911                 //mt:if %s.Field == HUDWorldPos
7912                 WorldPos Pos
7913
7914                 //mt:if %s.Field == HUDSize
7915                 Size [2]int32
7916
7917                 //mt:if %s.Field == HUDZIndex
7918                 ZIndex int32
7919
7920                 //mt:if %s.Field == HUDText2
7921                 Text2 string
7922         }))(obj)).Field == HUDText {
7923                 if len(([]byte((*(*(struct {
7924                         ID HUDID
7925
7926                         Field HUDField
7927
7928                         //mt:if %s.Field == HUDPos
7929                         Pos [2]float32
7930
7931                         //mt:if %s.Field == HUDName
7932                         Name string
7933
7934                         //mt:if %s.Field == HUDScale
7935                         Scale [2]float32
7936
7937                         //mt:if %s.Field == HUDText
7938                         Text string
7939
7940                         //mt:if %s.Field == HUDNumber
7941                         Number uint32
7942
7943                         //mt:if %s.Field == HUDItem
7944                         Item uint32
7945
7946                         //mt:if %s.Field == HUDDir
7947                         Dir uint32
7948
7949                         //mt:if %s.Field == HUDAlign
7950                         Align [2]float32
7951
7952                         //mt:if %s.Field == HUDOffset
7953                         Offset [2]float32
7954
7955                         //mt:if %s.Field == HUDWorldPos
7956                         WorldPos Pos
7957
7958                         //mt:if %s.Field == HUDSize
7959                         Size [2]int32
7960
7961                         //mt:if %s.Field == HUDZIndex
7962                         ZIndex int32
7963
7964                         //mt:if %s.Field == HUDText2
7965                         Text2 string
7966                 }))(obj)).Text))) > math.MaxUint16 {
7967                         chk(ErrTooLong)
7968                 }
7969                 {
7970                         x := uint16(len(([]byte((*(*(struct {
7971                                 ID HUDID
7972
7973                                 Field HUDField
7974
7975                                 //mt:if %s.Field == HUDPos
7976                                 Pos [2]float32
7977
7978                                 //mt:if %s.Field == HUDName
7979                                 Name string
7980
7981                                 //mt:if %s.Field == HUDScale
7982                                 Scale [2]float32
7983
7984                                 //mt:if %s.Field == HUDText
7985                                 Text string
7986
7987                                 //mt:if %s.Field == HUDNumber
7988                                 Number uint32
7989
7990                                 //mt:if %s.Field == HUDItem
7991                                 Item uint32
7992
7993                                 //mt:if %s.Field == HUDDir
7994                                 Dir uint32
7995
7996                                 //mt:if %s.Field == HUDAlign
7997                                 Align [2]float32
7998
7999                                 //mt:if %s.Field == HUDOffset
8000                                 Offset [2]float32
8001
8002                                 //mt:if %s.Field == HUDWorldPos
8003                                 WorldPos Pos
8004
8005                                 //mt:if %s.Field == HUDSize
8006                                 Size [2]int32
8007
8008                                 //mt:if %s.Field == HUDZIndex
8009                                 ZIndex int32
8010
8011                                 //mt:if %s.Field == HUDText2
8012                                 Text2 string
8013                         }))(obj)).Text))))
8014                         write16(w, uint16(x))
8015                 }
8016                 {
8017                         _, err := w.Write(([]byte((*(*(struct {
8018                                 ID HUDID
8019
8020                                 Field HUDField
8021
8022                                 //mt:if %s.Field == HUDPos
8023                                 Pos [2]float32
8024
8025                                 //mt:if %s.Field == HUDName
8026                                 Name string
8027
8028                                 //mt:if %s.Field == HUDScale
8029                                 Scale [2]float32
8030
8031                                 //mt:if %s.Field == HUDText
8032                                 Text string
8033
8034                                 //mt:if %s.Field == HUDNumber
8035                                 Number uint32
8036
8037                                 //mt:if %s.Field == HUDItem
8038                                 Item uint32
8039
8040                                 //mt:if %s.Field == HUDDir
8041                                 Dir uint32
8042
8043                                 //mt:if %s.Field == HUDAlign
8044                                 Align [2]float32
8045
8046                                 //mt:if %s.Field == HUDOffset
8047                                 Offset [2]float32
8048
8049                                 //mt:if %s.Field == HUDWorldPos
8050                                 WorldPos Pos
8051
8052                                 //mt:if %s.Field == HUDSize
8053                                 Size [2]int32
8054
8055                                 //mt:if %s.Field == HUDZIndex
8056                                 ZIndex int32
8057
8058                                 //mt:if %s.Field == HUDText2
8059                                 Text2 string
8060                         }))(obj)).Text))[:])
8061                         chk(err)
8062                 }
8063         }
8064         if (*(*(struct {
8065                 ID HUDID
8066
8067                 Field HUDField
8068
8069                 //mt:if %s.Field == HUDPos
8070                 Pos [2]float32
8071
8072                 //mt:if %s.Field == HUDName
8073                 Name string
8074
8075                 //mt:if %s.Field == HUDScale
8076                 Scale [2]float32
8077
8078                 //mt:if %s.Field == HUDText
8079                 Text string
8080
8081                 //mt:if %s.Field == HUDNumber
8082                 Number uint32
8083
8084                 //mt:if %s.Field == HUDItem
8085                 Item uint32
8086
8087                 //mt:if %s.Field == HUDDir
8088                 Dir uint32
8089
8090                 //mt:if %s.Field == HUDAlign
8091                 Align [2]float32
8092
8093                 //mt:if %s.Field == HUDOffset
8094                 Offset [2]float32
8095
8096                 //mt:if %s.Field == HUDWorldPos
8097                 WorldPos Pos
8098
8099                 //mt:if %s.Field == HUDSize
8100                 Size [2]int32
8101
8102                 //mt:if %s.Field == HUDZIndex
8103                 ZIndex int32
8104
8105                 //mt:if %s.Field == HUDText2
8106                 Text2 string
8107         }))(obj)).Field == HUDNumber {
8108                 {
8109                         x := (*(*(struct {
8110                                 ID HUDID
8111
8112                                 Field HUDField
8113
8114                                 //mt:if %s.Field == HUDPos
8115                                 Pos [2]float32
8116
8117                                 //mt:if %s.Field == HUDName
8118                                 Name string
8119
8120                                 //mt:if %s.Field == HUDScale
8121                                 Scale [2]float32
8122
8123                                 //mt:if %s.Field == HUDText
8124                                 Text string
8125
8126                                 //mt:if %s.Field == HUDNumber
8127                                 Number uint32
8128
8129                                 //mt:if %s.Field == HUDItem
8130                                 Item uint32
8131
8132                                 //mt:if %s.Field == HUDDir
8133                                 Dir uint32
8134
8135                                 //mt:if %s.Field == HUDAlign
8136                                 Align [2]float32
8137
8138                                 //mt:if %s.Field == HUDOffset
8139                                 Offset [2]float32
8140
8141                                 //mt:if %s.Field == HUDWorldPos
8142                                 WorldPos Pos
8143
8144                                 //mt:if %s.Field == HUDSize
8145                                 Size [2]int32
8146
8147                                 //mt:if %s.Field == HUDZIndex
8148                                 ZIndex int32
8149
8150                                 //mt:if %s.Field == HUDText2
8151                                 Text2 string
8152                         }))(obj)).Number
8153                         write32(w, uint32(x))
8154                 }
8155         }
8156         if (*(*(struct {
8157                 ID HUDID
8158
8159                 Field HUDField
8160
8161                 //mt:if %s.Field == HUDPos
8162                 Pos [2]float32
8163
8164                 //mt:if %s.Field == HUDName
8165                 Name string
8166
8167                 //mt:if %s.Field == HUDScale
8168                 Scale [2]float32
8169
8170                 //mt:if %s.Field == HUDText
8171                 Text string
8172
8173                 //mt:if %s.Field == HUDNumber
8174                 Number uint32
8175
8176                 //mt:if %s.Field == HUDItem
8177                 Item uint32
8178
8179                 //mt:if %s.Field == HUDDir
8180                 Dir uint32
8181
8182                 //mt:if %s.Field == HUDAlign
8183                 Align [2]float32
8184
8185                 //mt:if %s.Field == HUDOffset
8186                 Offset [2]float32
8187
8188                 //mt:if %s.Field == HUDWorldPos
8189                 WorldPos Pos
8190
8191                 //mt:if %s.Field == HUDSize
8192                 Size [2]int32
8193
8194                 //mt:if %s.Field == HUDZIndex
8195                 ZIndex int32
8196
8197                 //mt:if %s.Field == HUDText2
8198                 Text2 string
8199         }))(obj)).Field == HUDItem {
8200                 {
8201                         x := (*(*(struct {
8202                                 ID HUDID
8203
8204                                 Field HUDField
8205
8206                                 //mt:if %s.Field == HUDPos
8207                                 Pos [2]float32
8208
8209                                 //mt:if %s.Field == HUDName
8210                                 Name string
8211
8212                                 //mt:if %s.Field == HUDScale
8213                                 Scale [2]float32
8214
8215                                 //mt:if %s.Field == HUDText
8216                                 Text string
8217
8218                                 //mt:if %s.Field == HUDNumber
8219                                 Number uint32
8220
8221                                 //mt:if %s.Field == HUDItem
8222                                 Item uint32
8223
8224                                 //mt:if %s.Field == HUDDir
8225                                 Dir uint32
8226
8227                                 //mt:if %s.Field == HUDAlign
8228                                 Align [2]float32
8229
8230                                 //mt:if %s.Field == HUDOffset
8231                                 Offset [2]float32
8232
8233                                 //mt:if %s.Field == HUDWorldPos
8234                                 WorldPos Pos
8235
8236                                 //mt:if %s.Field == HUDSize
8237                                 Size [2]int32
8238
8239                                 //mt:if %s.Field == HUDZIndex
8240                                 ZIndex int32
8241
8242                                 //mt:if %s.Field == HUDText2
8243                                 Text2 string
8244                         }))(obj)).Item
8245                         write32(w, uint32(x))
8246                 }
8247         }
8248         if (*(*(struct {
8249                 ID HUDID
8250
8251                 Field HUDField
8252
8253                 //mt:if %s.Field == HUDPos
8254                 Pos [2]float32
8255
8256                 //mt:if %s.Field == HUDName
8257                 Name string
8258
8259                 //mt:if %s.Field == HUDScale
8260                 Scale [2]float32
8261
8262                 //mt:if %s.Field == HUDText
8263                 Text string
8264
8265                 //mt:if %s.Field == HUDNumber
8266                 Number uint32
8267
8268                 //mt:if %s.Field == HUDItem
8269                 Item uint32
8270
8271                 //mt:if %s.Field == HUDDir
8272                 Dir uint32
8273
8274                 //mt:if %s.Field == HUDAlign
8275                 Align [2]float32
8276
8277                 //mt:if %s.Field == HUDOffset
8278                 Offset [2]float32
8279
8280                 //mt:if %s.Field == HUDWorldPos
8281                 WorldPos Pos
8282
8283                 //mt:if %s.Field == HUDSize
8284                 Size [2]int32
8285
8286                 //mt:if %s.Field == HUDZIndex
8287                 ZIndex int32
8288
8289                 //mt:if %s.Field == HUDText2
8290                 Text2 string
8291         }))(obj)).Field == HUDDir {
8292                 {
8293                         x := (*(*(struct {
8294                                 ID HUDID
8295
8296                                 Field HUDField
8297
8298                                 //mt:if %s.Field == HUDPos
8299                                 Pos [2]float32
8300
8301                                 //mt:if %s.Field == HUDName
8302                                 Name string
8303
8304                                 //mt:if %s.Field == HUDScale
8305                                 Scale [2]float32
8306
8307                                 //mt:if %s.Field == HUDText
8308                                 Text string
8309
8310                                 //mt:if %s.Field == HUDNumber
8311                                 Number uint32
8312
8313                                 //mt:if %s.Field == HUDItem
8314                                 Item uint32
8315
8316                                 //mt:if %s.Field == HUDDir
8317                                 Dir uint32
8318
8319                                 //mt:if %s.Field == HUDAlign
8320                                 Align [2]float32
8321
8322                                 //mt:if %s.Field == HUDOffset
8323                                 Offset [2]float32
8324
8325                                 //mt:if %s.Field == HUDWorldPos
8326                                 WorldPos Pos
8327
8328                                 //mt:if %s.Field == HUDSize
8329                                 Size [2]int32
8330
8331                                 //mt:if %s.Field == HUDZIndex
8332                                 ZIndex int32
8333
8334                                 //mt:if %s.Field == HUDText2
8335                                 Text2 string
8336                         }))(obj)).Dir
8337                         write32(w, uint32(x))
8338                 }
8339         }
8340         if (*(*(struct {
8341                 ID HUDID
8342
8343                 Field HUDField
8344
8345                 //mt:if %s.Field == HUDPos
8346                 Pos [2]float32
8347
8348                 //mt:if %s.Field == HUDName
8349                 Name string
8350
8351                 //mt:if %s.Field == HUDScale
8352                 Scale [2]float32
8353
8354                 //mt:if %s.Field == HUDText
8355                 Text string
8356
8357                 //mt:if %s.Field == HUDNumber
8358                 Number uint32
8359
8360                 //mt:if %s.Field == HUDItem
8361                 Item uint32
8362
8363                 //mt:if %s.Field == HUDDir
8364                 Dir uint32
8365
8366                 //mt:if %s.Field == HUDAlign
8367                 Align [2]float32
8368
8369                 //mt:if %s.Field == HUDOffset
8370                 Offset [2]float32
8371
8372                 //mt:if %s.Field == HUDWorldPos
8373                 WorldPos Pos
8374
8375                 //mt:if %s.Field == HUDSize
8376                 Size [2]int32
8377
8378                 //mt:if %s.Field == HUDZIndex
8379                 ZIndex int32
8380
8381                 //mt:if %s.Field == HUDText2
8382                 Text2 string
8383         }))(obj)).Field == HUDAlign {
8384                 for local174 := range (*(*(struct {
8385                         ID HUDID
8386
8387                         Field HUDField
8388
8389                         //mt:if %s.Field == HUDPos
8390                         Pos [2]float32
8391
8392                         //mt:if %s.Field == HUDName
8393                         Name string
8394
8395                         //mt:if %s.Field == HUDScale
8396                         Scale [2]float32
8397
8398                         //mt:if %s.Field == HUDText
8399                         Text string
8400
8401                         //mt:if %s.Field == HUDNumber
8402                         Number uint32
8403
8404                         //mt:if %s.Field == HUDItem
8405                         Item uint32
8406
8407                         //mt:if %s.Field == HUDDir
8408                         Dir uint32
8409
8410                         //mt:if %s.Field == HUDAlign
8411                         Align [2]float32
8412
8413                         //mt:if %s.Field == HUDOffset
8414                         Offset [2]float32
8415
8416                         //mt:if %s.Field == HUDWorldPos
8417                         WorldPos Pos
8418
8419                         //mt:if %s.Field == HUDSize
8420                         Size [2]int32
8421
8422                         //mt:if %s.Field == HUDZIndex
8423                         ZIndex int32
8424
8425                         //mt:if %s.Field == HUDText2
8426                         Text2 string
8427                 }))(obj)).Align {
8428                         {
8429                                 x := ((*(*(struct {
8430                                         ID HUDID
8431
8432                                         Field HUDField
8433
8434                                         //mt:if %s.Field == HUDPos
8435                                         Pos [2]float32
8436
8437                                         //mt:if %s.Field == HUDName
8438                                         Name string
8439
8440                                         //mt:if %s.Field == HUDScale
8441                                         Scale [2]float32
8442
8443                                         //mt:if %s.Field == HUDText
8444                                         Text string
8445
8446                                         //mt:if %s.Field == HUDNumber
8447                                         Number uint32
8448
8449                                         //mt:if %s.Field == HUDItem
8450                                         Item uint32
8451
8452                                         //mt:if %s.Field == HUDDir
8453                                         Dir uint32
8454
8455                                         //mt:if %s.Field == HUDAlign
8456                                         Align [2]float32
8457
8458                                         //mt:if %s.Field == HUDOffset
8459                                         Offset [2]float32
8460
8461                                         //mt:if %s.Field == HUDWorldPos
8462                                         WorldPos Pos
8463
8464                                         //mt:if %s.Field == HUDSize
8465                                         Size [2]int32
8466
8467                                         //mt:if %s.Field == HUDZIndex
8468                                         ZIndex int32
8469
8470                                         //mt:if %s.Field == HUDText2
8471                                         Text2 string
8472                                 }))(obj)).Align)[local174]
8473                                 write32(w, math.Float32bits(x))
8474                         }
8475                 }
8476         }
8477         if (*(*(struct {
8478                 ID HUDID
8479
8480                 Field HUDField
8481
8482                 //mt:if %s.Field == HUDPos
8483                 Pos [2]float32
8484
8485                 //mt:if %s.Field == HUDName
8486                 Name string
8487
8488                 //mt:if %s.Field == HUDScale
8489                 Scale [2]float32
8490
8491                 //mt:if %s.Field == HUDText
8492                 Text string
8493
8494                 //mt:if %s.Field == HUDNumber
8495                 Number uint32
8496
8497                 //mt:if %s.Field == HUDItem
8498                 Item uint32
8499
8500                 //mt:if %s.Field == HUDDir
8501                 Dir uint32
8502
8503                 //mt:if %s.Field == HUDAlign
8504                 Align [2]float32
8505
8506                 //mt:if %s.Field == HUDOffset
8507                 Offset [2]float32
8508
8509                 //mt:if %s.Field == HUDWorldPos
8510                 WorldPos Pos
8511
8512                 //mt:if %s.Field == HUDSize
8513                 Size [2]int32
8514
8515                 //mt:if %s.Field == HUDZIndex
8516                 ZIndex int32
8517
8518                 //mt:if %s.Field == HUDText2
8519                 Text2 string
8520         }))(obj)).Field == HUDOffset {
8521                 for local175 := range (*(*(struct {
8522                         ID HUDID
8523
8524                         Field HUDField
8525
8526                         //mt:if %s.Field == HUDPos
8527                         Pos [2]float32
8528
8529                         //mt:if %s.Field == HUDName
8530                         Name string
8531
8532                         //mt:if %s.Field == HUDScale
8533                         Scale [2]float32
8534
8535                         //mt:if %s.Field == HUDText
8536                         Text string
8537
8538                         //mt:if %s.Field == HUDNumber
8539                         Number uint32
8540
8541                         //mt:if %s.Field == HUDItem
8542                         Item uint32
8543
8544                         //mt:if %s.Field == HUDDir
8545                         Dir uint32
8546
8547                         //mt:if %s.Field == HUDAlign
8548                         Align [2]float32
8549
8550                         //mt:if %s.Field == HUDOffset
8551                         Offset [2]float32
8552
8553                         //mt:if %s.Field == HUDWorldPos
8554                         WorldPos Pos
8555
8556                         //mt:if %s.Field == HUDSize
8557                         Size [2]int32
8558
8559                         //mt:if %s.Field == HUDZIndex
8560                         ZIndex int32
8561
8562                         //mt:if %s.Field == HUDText2
8563                         Text2 string
8564                 }))(obj)).Offset {
8565                         {
8566                                 x := ((*(*(struct {
8567                                         ID HUDID
8568
8569                                         Field HUDField
8570
8571                                         //mt:if %s.Field == HUDPos
8572                                         Pos [2]float32
8573
8574                                         //mt:if %s.Field == HUDName
8575                                         Name string
8576
8577                                         //mt:if %s.Field == HUDScale
8578                                         Scale [2]float32
8579
8580                                         //mt:if %s.Field == HUDText
8581                                         Text string
8582
8583                                         //mt:if %s.Field == HUDNumber
8584                                         Number uint32
8585
8586                                         //mt:if %s.Field == HUDItem
8587                                         Item uint32
8588
8589                                         //mt:if %s.Field == HUDDir
8590                                         Dir uint32
8591
8592                                         //mt:if %s.Field == HUDAlign
8593                                         Align [2]float32
8594
8595                                         //mt:if %s.Field == HUDOffset
8596                                         Offset [2]float32
8597
8598                                         //mt:if %s.Field == HUDWorldPos
8599                                         WorldPos Pos
8600
8601                                         //mt:if %s.Field == HUDSize
8602                                         Size [2]int32
8603
8604                                         //mt:if %s.Field == HUDZIndex
8605                                         ZIndex int32
8606
8607                                         //mt:if %s.Field == HUDText2
8608                                         Text2 string
8609                                 }))(obj)).Offset)[local175]
8610                                 write32(w, math.Float32bits(x))
8611                         }
8612                 }
8613         }
8614         if (*(*(struct {
8615                 ID HUDID
8616
8617                 Field HUDField
8618
8619                 //mt:if %s.Field == HUDPos
8620                 Pos [2]float32
8621
8622                 //mt:if %s.Field == HUDName
8623                 Name string
8624
8625                 //mt:if %s.Field == HUDScale
8626                 Scale [2]float32
8627
8628                 //mt:if %s.Field == HUDText
8629                 Text string
8630
8631                 //mt:if %s.Field == HUDNumber
8632                 Number uint32
8633
8634                 //mt:if %s.Field == HUDItem
8635                 Item uint32
8636
8637                 //mt:if %s.Field == HUDDir
8638                 Dir uint32
8639
8640                 //mt:if %s.Field == HUDAlign
8641                 Align [2]float32
8642
8643                 //mt:if %s.Field == HUDOffset
8644                 Offset [2]float32
8645
8646                 //mt:if %s.Field == HUDWorldPos
8647                 WorldPos Pos
8648
8649                 //mt:if %s.Field == HUDSize
8650                 Size [2]int32
8651
8652                 //mt:if %s.Field == HUDZIndex
8653                 ZIndex int32
8654
8655                 //mt:if %s.Field == HUDText2
8656                 Text2 string
8657         }))(obj)).Field == HUDWorldPos {
8658                 if err := pcall(func() {
8659                         ((*(*(struct {
8660                                 ID HUDID
8661
8662                                 Field HUDField
8663
8664                                 //mt:if %s.Field == HUDPos
8665                                 Pos [2]float32
8666
8667                                 //mt:if %s.Field == HUDName
8668                                 Name string
8669
8670                                 //mt:if %s.Field == HUDScale
8671                                 Scale [2]float32
8672
8673                                 //mt:if %s.Field == HUDText
8674                                 Text string
8675
8676                                 //mt:if %s.Field == HUDNumber
8677                                 Number uint32
8678
8679                                 //mt:if %s.Field == HUDItem
8680                                 Item uint32
8681
8682                                 //mt:if %s.Field == HUDDir
8683                                 Dir uint32
8684
8685                                 //mt:if %s.Field == HUDAlign
8686                                 Align [2]float32
8687
8688                                 //mt:if %s.Field == HUDOffset
8689                                 Offset [2]float32
8690
8691                                 //mt:if %s.Field == HUDWorldPos
8692                                 WorldPos Pos
8693
8694                                 //mt:if %s.Field == HUDSize
8695                                 Size [2]int32
8696
8697                                 //mt:if %s.Field == HUDZIndex
8698                                 ZIndex int32
8699
8700                                 //mt:if %s.Field == HUDText2
8701                                 Text2 string
8702                         }))(obj)).WorldPos).serialize(w)
8703                 }); err != nil {
8704                         if err == io.EOF {
8705                                 chk(io.EOF)
8706                         }
8707                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
8708                 }
8709         }
8710         if (*(*(struct {
8711                 ID HUDID
8712
8713                 Field HUDField
8714
8715                 //mt:if %s.Field == HUDPos
8716                 Pos [2]float32
8717
8718                 //mt:if %s.Field == HUDName
8719                 Name string
8720
8721                 //mt:if %s.Field == HUDScale
8722                 Scale [2]float32
8723
8724                 //mt:if %s.Field == HUDText
8725                 Text string
8726
8727                 //mt:if %s.Field == HUDNumber
8728                 Number uint32
8729
8730                 //mt:if %s.Field == HUDItem
8731                 Item uint32
8732
8733                 //mt:if %s.Field == HUDDir
8734                 Dir uint32
8735
8736                 //mt:if %s.Field == HUDAlign
8737                 Align [2]float32
8738
8739                 //mt:if %s.Field == HUDOffset
8740                 Offset [2]float32
8741
8742                 //mt:if %s.Field == HUDWorldPos
8743                 WorldPos Pos
8744
8745                 //mt:if %s.Field == HUDSize
8746                 Size [2]int32
8747
8748                 //mt:if %s.Field == HUDZIndex
8749                 ZIndex int32
8750
8751                 //mt:if %s.Field == HUDText2
8752                 Text2 string
8753         }))(obj)).Field == HUDSize {
8754                 for local176 := range (*(*(struct {
8755                         ID HUDID
8756
8757                         Field HUDField
8758
8759                         //mt:if %s.Field == HUDPos
8760                         Pos [2]float32
8761
8762                         //mt:if %s.Field == HUDName
8763                         Name string
8764
8765                         //mt:if %s.Field == HUDScale
8766                         Scale [2]float32
8767
8768                         //mt:if %s.Field == HUDText
8769                         Text string
8770
8771                         //mt:if %s.Field == HUDNumber
8772                         Number uint32
8773
8774                         //mt:if %s.Field == HUDItem
8775                         Item uint32
8776
8777                         //mt:if %s.Field == HUDDir
8778                         Dir uint32
8779
8780                         //mt:if %s.Field == HUDAlign
8781                         Align [2]float32
8782
8783                         //mt:if %s.Field == HUDOffset
8784                         Offset [2]float32
8785
8786                         //mt:if %s.Field == HUDWorldPos
8787                         WorldPos Pos
8788
8789                         //mt:if %s.Field == HUDSize
8790                         Size [2]int32
8791
8792                         //mt:if %s.Field == HUDZIndex
8793                         ZIndex int32
8794
8795                         //mt:if %s.Field == HUDText2
8796                         Text2 string
8797                 }))(obj)).Size {
8798                         {
8799                                 x := ((*(*(struct {
8800                                         ID HUDID
8801
8802                                         Field HUDField
8803
8804                                         //mt:if %s.Field == HUDPos
8805                                         Pos [2]float32
8806
8807                                         //mt:if %s.Field == HUDName
8808                                         Name string
8809
8810                                         //mt:if %s.Field == HUDScale
8811                                         Scale [2]float32
8812
8813                                         //mt:if %s.Field == HUDText
8814                                         Text string
8815
8816                                         //mt:if %s.Field == HUDNumber
8817                                         Number uint32
8818
8819                                         //mt:if %s.Field == HUDItem
8820                                         Item uint32
8821
8822                                         //mt:if %s.Field == HUDDir
8823                                         Dir uint32
8824
8825                                         //mt:if %s.Field == HUDAlign
8826                                         Align [2]float32
8827
8828                                         //mt:if %s.Field == HUDOffset
8829                                         Offset [2]float32
8830
8831                                         //mt:if %s.Field == HUDWorldPos
8832                                         WorldPos Pos
8833
8834                                         //mt:if %s.Field == HUDSize
8835                                         Size [2]int32
8836
8837                                         //mt:if %s.Field == HUDZIndex
8838                                         ZIndex int32
8839
8840                                         //mt:if %s.Field == HUDText2
8841                                         Text2 string
8842                                 }))(obj)).Size)[local176]
8843                                 write32(w, uint32(x))
8844                         }
8845                 }
8846         }
8847         if (*(*(struct {
8848                 ID HUDID
8849
8850                 Field HUDField
8851
8852                 //mt:if %s.Field == HUDPos
8853                 Pos [2]float32
8854
8855                 //mt:if %s.Field == HUDName
8856                 Name string
8857
8858                 //mt:if %s.Field == HUDScale
8859                 Scale [2]float32
8860
8861                 //mt:if %s.Field == HUDText
8862                 Text string
8863
8864                 //mt:if %s.Field == HUDNumber
8865                 Number uint32
8866
8867                 //mt:if %s.Field == HUDItem
8868                 Item uint32
8869
8870                 //mt:if %s.Field == HUDDir
8871                 Dir uint32
8872
8873                 //mt:if %s.Field == HUDAlign
8874                 Align [2]float32
8875
8876                 //mt:if %s.Field == HUDOffset
8877                 Offset [2]float32
8878
8879                 //mt:if %s.Field == HUDWorldPos
8880                 WorldPos Pos
8881
8882                 //mt:if %s.Field == HUDSize
8883                 Size [2]int32
8884
8885                 //mt:if %s.Field == HUDZIndex
8886                 ZIndex int32
8887
8888                 //mt:if %s.Field == HUDText2
8889                 Text2 string
8890         }))(obj)).Field == HUDZIndex {
8891                 {
8892                         x := (*(*(struct {
8893                                 ID HUDID
8894
8895                                 Field HUDField
8896
8897                                 //mt:if %s.Field == HUDPos
8898                                 Pos [2]float32
8899
8900                                 //mt:if %s.Field == HUDName
8901                                 Name string
8902
8903                                 //mt:if %s.Field == HUDScale
8904                                 Scale [2]float32
8905
8906                                 //mt:if %s.Field == HUDText
8907                                 Text string
8908
8909                                 //mt:if %s.Field == HUDNumber
8910                                 Number uint32
8911
8912                                 //mt:if %s.Field == HUDItem
8913                                 Item uint32
8914
8915                                 //mt:if %s.Field == HUDDir
8916                                 Dir uint32
8917
8918                                 //mt:if %s.Field == HUDAlign
8919                                 Align [2]float32
8920
8921                                 //mt:if %s.Field == HUDOffset
8922                                 Offset [2]float32
8923
8924                                 //mt:if %s.Field == HUDWorldPos
8925                                 WorldPos Pos
8926
8927                                 //mt:if %s.Field == HUDSize
8928                                 Size [2]int32
8929
8930                                 //mt:if %s.Field == HUDZIndex
8931                                 ZIndex int32
8932
8933                                 //mt:if %s.Field == HUDText2
8934                                 Text2 string
8935                         }))(obj)).ZIndex
8936                         write32(w, uint32(x))
8937                 }
8938         }
8939         if (*(*(struct {
8940                 ID HUDID
8941
8942                 Field HUDField
8943
8944                 //mt:if %s.Field == HUDPos
8945                 Pos [2]float32
8946
8947                 //mt:if %s.Field == HUDName
8948                 Name string
8949
8950                 //mt:if %s.Field == HUDScale
8951                 Scale [2]float32
8952
8953                 //mt:if %s.Field == HUDText
8954                 Text string
8955
8956                 //mt:if %s.Field == HUDNumber
8957                 Number uint32
8958
8959                 //mt:if %s.Field == HUDItem
8960                 Item uint32
8961
8962                 //mt:if %s.Field == HUDDir
8963                 Dir uint32
8964
8965                 //mt:if %s.Field == HUDAlign
8966                 Align [2]float32
8967
8968                 //mt:if %s.Field == HUDOffset
8969                 Offset [2]float32
8970
8971                 //mt:if %s.Field == HUDWorldPos
8972                 WorldPos Pos
8973
8974                 //mt:if %s.Field == HUDSize
8975                 Size [2]int32
8976
8977                 //mt:if %s.Field == HUDZIndex
8978                 ZIndex int32
8979
8980                 //mt:if %s.Field == HUDText2
8981                 Text2 string
8982         }))(obj)).Field == HUDText2 {
8983                 if len(([]byte((*(*(struct {
8984                         ID HUDID
8985
8986                         Field HUDField
8987
8988                         //mt:if %s.Field == HUDPos
8989                         Pos [2]float32
8990
8991                         //mt:if %s.Field == HUDName
8992                         Name string
8993
8994                         //mt:if %s.Field == HUDScale
8995                         Scale [2]float32
8996
8997                         //mt:if %s.Field == HUDText
8998                         Text string
8999
9000                         //mt:if %s.Field == HUDNumber
9001                         Number uint32
9002
9003                         //mt:if %s.Field == HUDItem
9004                         Item uint32
9005
9006                         //mt:if %s.Field == HUDDir
9007                         Dir uint32
9008
9009                         //mt:if %s.Field == HUDAlign
9010                         Align [2]float32
9011
9012                         //mt:if %s.Field == HUDOffset
9013                         Offset [2]float32
9014
9015                         //mt:if %s.Field == HUDWorldPos
9016                         WorldPos Pos
9017
9018                         //mt:if %s.Field == HUDSize
9019                         Size [2]int32
9020
9021                         //mt:if %s.Field == HUDZIndex
9022                         ZIndex int32
9023
9024                         //mt:if %s.Field == HUDText2
9025                         Text2 string
9026                 }))(obj)).Text2))) > math.MaxUint16 {
9027                         chk(ErrTooLong)
9028                 }
9029                 {
9030                         x := uint16(len(([]byte((*(*(struct {
9031                                 ID HUDID
9032
9033                                 Field HUDField
9034
9035                                 //mt:if %s.Field == HUDPos
9036                                 Pos [2]float32
9037
9038                                 //mt:if %s.Field == HUDName
9039                                 Name string
9040
9041                                 //mt:if %s.Field == HUDScale
9042                                 Scale [2]float32
9043
9044                                 //mt:if %s.Field == HUDText
9045                                 Text string
9046
9047                                 //mt:if %s.Field == HUDNumber
9048                                 Number uint32
9049
9050                                 //mt:if %s.Field == HUDItem
9051                                 Item uint32
9052
9053                                 //mt:if %s.Field == HUDDir
9054                                 Dir uint32
9055
9056                                 //mt:if %s.Field == HUDAlign
9057                                 Align [2]float32
9058
9059                                 //mt:if %s.Field == HUDOffset
9060                                 Offset [2]float32
9061
9062                                 //mt:if %s.Field == HUDWorldPos
9063                                 WorldPos Pos
9064
9065                                 //mt:if %s.Field == HUDSize
9066                                 Size [2]int32
9067
9068                                 //mt:if %s.Field == HUDZIndex
9069                                 ZIndex int32
9070
9071                                 //mt:if %s.Field == HUDText2
9072                                 Text2 string
9073                         }))(obj)).Text2))))
9074                         write16(w, uint16(x))
9075                 }
9076                 {
9077                         _, err := w.Write(([]byte((*(*(struct {
9078                                 ID HUDID
9079
9080                                 Field HUDField
9081
9082                                 //mt:if %s.Field == HUDPos
9083                                 Pos [2]float32
9084
9085                                 //mt:if %s.Field == HUDName
9086                                 Name string
9087
9088                                 //mt:if %s.Field == HUDScale
9089                                 Scale [2]float32
9090
9091                                 //mt:if %s.Field == HUDText
9092                                 Text string
9093
9094                                 //mt:if %s.Field == HUDNumber
9095                                 Number uint32
9096
9097                                 //mt:if %s.Field == HUDItem
9098                                 Item uint32
9099
9100                                 //mt:if %s.Field == HUDDir
9101                                 Dir uint32
9102
9103                                 //mt:if %s.Field == HUDAlign
9104                                 Align [2]float32
9105
9106                                 //mt:if %s.Field == HUDOffset
9107                                 Offset [2]float32
9108
9109                                 //mt:if %s.Field == HUDWorldPos
9110                                 WorldPos Pos
9111
9112                                 //mt:if %s.Field == HUDSize
9113                                 Size [2]int32
9114
9115                                 //mt:if %s.Field == HUDZIndex
9116                                 ZIndex int32
9117
9118                                 //mt:if %s.Field == HUDText2
9119                                 Text2 string
9120                         }))(obj)).Text2))[:])
9121                         chk(err)
9122                 }
9123         }
9124 }
9125
9126 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9127         if err := pcall(func() {
9128                 ((*(*(struct {
9129                         ID HUDID
9130
9131                         Field HUDField
9132
9133                         //mt:if %s.Field == HUDPos
9134                         Pos [2]float32
9135
9136                         //mt:if %s.Field == HUDName
9137                         Name string
9138
9139                         //mt:if %s.Field == HUDScale
9140                         Scale [2]float32
9141
9142                         //mt:if %s.Field == HUDText
9143                         Text string
9144
9145                         //mt:if %s.Field == HUDNumber
9146                         Number uint32
9147
9148                         //mt:if %s.Field == HUDItem
9149                         Item uint32
9150
9151                         //mt:if %s.Field == HUDDir
9152                         Dir uint32
9153
9154                         //mt:if %s.Field == HUDAlign
9155                         Align [2]float32
9156
9157                         //mt:if %s.Field == HUDOffset
9158                         Offset [2]float32
9159
9160                         //mt:if %s.Field == HUDWorldPos
9161                         WorldPos Pos
9162
9163                         //mt:if %s.Field == HUDSize
9164                         Size [2]int32
9165
9166                         //mt:if %s.Field == HUDZIndex
9167                         ZIndex int32
9168
9169                         //mt:if %s.Field == HUDText2
9170                         Text2 string
9171                 }))(obj)).ID).deserialize(r)
9172         }); err != nil {
9173                 if err == io.EOF {
9174                         chk(io.EOF)
9175                 }
9176                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
9177         }
9178         if err := pcall(func() {
9179                 ((*(*(struct {
9180                         ID HUDID
9181
9182                         Field HUDField
9183
9184                         //mt:if %s.Field == HUDPos
9185                         Pos [2]float32
9186
9187                         //mt:if %s.Field == HUDName
9188                         Name string
9189
9190                         //mt:if %s.Field == HUDScale
9191                         Scale [2]float32
9192
9193                         //mt:if %s.Field == HUDText
9194                         Text string
9195
9196                         //mt:if %s.Field == HUDNumber
9197                         Number uint32
9198
9199                         //mt:if %s.Field == HUDItem
9200                         Item uint32
9201
9202                         //mt:if %s.Field == HUDDir
9203                         Dir uint32
9204
9205                         //mt:if %s.Field == HUDAlign
9206                         Align [2]float32
9207
9208                         //mt:if %s.Field == HUDOffset
9209                         Offset [2]float32
9210
9211                         //mt:if %s.Field == HUDWorldPos
9212                         WorldPos Pos
9213
9214                         //mt:if %s.Field == HUDSize
9215                         Size [2]int32
9216
9217                         //mt:if %s.Field == HUDZIndex
9218                         ZIndex int32
9219
9220                         //mt:if %s.Field == HUDText2
9221                         Text2 string
9222                 }))(obj)).Field).deserialize(r)
9223         }); err != nil {
9224                 if err == io.EOF {
9225                         chk(io.EOF)
9226                 }
9227                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDField", err))
9228         }
9229         if !((*(*(struct {
9230                 ID HUDID
9231
9232                 Field HUDField
9233
9234                 //mt:if %s.Field == HUDPos
9235                 Pos [2]float32
9236
9237                 //mt:if %s.Field == HUDName
9238                 Name string
9239
9240                 //mt:if %s.Field == HUDScale
9241                 Scale [2]float32
9242
9243                 //mt:if %s.Field == HUDText
9244                 Text string
9245
9246                 //mt:if %s.Field == HUDNumber
9247                 Number uint32
9248
9249                 //mt:if %s.Field == HUDItem
9250                 Item uint32
9251
9252                 //mt:if %s.Field == HUDDir
9253                 Dir uint32
9254
9255                 //mt:if %s.Field == HUDAlign
9256                 Align [2]float32
9257
9258                 //mt:if %s.Field == HUDOffset
9259                 Offset [2]float32
9260
9261                 //mt:if %s.Field == HUDWorldPos
9262                 WorldPos Pos
9263
9264                 //mt:if %s.Field == HUDSize
9265                 Size [2]int32
9266
9267                 //mt:if %s.Field == HUDZIndex
9268                 ZIndex int32
9269
9270                 //mt:if %s.Field == HUDText2
9271                 Text2 string
9272         }))(obj)).Field < hudMax) {
9273                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9274         }
9275         if (*(*(struct {
9276                 ID HUDID
9277
9278                 Field HUDField
9279
9280                 //mt:if %s.Field == HUDPos
9281                 Pos [2]float32
9282
9283                 //mt:if %s.Field == HUDName
9284                 Name string
9285
9286                 //mt:if %s.Field == HUDScale
9287                 Scale [2]float32
9288
9289                 //mt:if %s.Field == HUDText
9290                 Text string
9291
9292                 //mt:if %s.Field == HUDNumber
9293                 Number uint32
9294
9295                 //mt:if %s.Field == HUDItem
9296                 Item uint32
9297
9298                 //mt:if %s.Field == HUDDir
9299                 Dir uint32
9300
9301                 //mt:if %s.Field == HUDAlign
9302                 Align [2]float32
9303
9304                 //mt:if %s.Field == HUDOffset
9305                 Offset [2]float32
9306
9307                 //mt:if %s.Field == HUDWorldPos
9308                 WorldPos Pos
9309
9310                 //mt:if %s.Field == HUDSize
9311                 Size [2]int32
9312
9313                 //mt:if %s.Field == HUDZIndex
9314                 ZIndex int32
9315
9316                 //mt:if %s.Field == HUDText2
9317                 Text2 string
9318         }))(obj)).Field == HUDPos {
9319                 for local177 := range (*(*(struct {
9320                         ID HUDID
9321
9322                         Field HUDField
9323
9324                         //mt:if %s.Field == HUDPos
9325                         Pos [2]float32
9326
9327                         //mt:if %s.Field == HUDName
9328                         Name string
9329
9330                         //mt:if %s.Field == HUDScale
9331                         Scale [2]float32
9332
9333                         //mt:if %s.Field == HUDText
9334                         Text string
9335
9336                         //mt:if %s.Field == HUDNumber
9337                         Number uint32
9338
9339                         //mt:if %s.Field == HUDItem
9340                         Item uint32
9341
9342                         //mt:if %s.Field == HUDDir
9343                         Dir uint32
9344
9345                         //mt:if %s.Field == HUDAlign
9346                         Align [2]float32
9347
9348                         //mt:if %s.Field == HUDOffset
9349                         Offset [2]float32
9350
9351                         //mt:if %s.Field == HUDWorldPos
9352                         WorldPos Pos
9353
9354                         //mt:if %s.Field == HUDSize
9355                         Size [2]int32
9356
9357                         //mt:if %s.Field == HUDZIndex
9358                         ZIndex int32
9359
9360                         //mt:if %s.Field == HUDText2
9361                         Text2 string
9362                 }))(obj)).Pos {
9363                         {
9364                                 p := &((*(*(struct {
9365                                         ID HUDID
9366
9367                                         Field HUDField
9368
9369                                         //mt:if %s.Field == HUDPos
9370                                         Pos [2]float32
9371
9372                                         //mt:if %s.Field == HUDName
9373                                         Name string
9374
9375                                         //mt:if %s.Field == HUDScale
9376                                         Scale [2]float32
9377
9378                                         //mt:if %s.Field == HUDText
9379                                         Text string
9380
9381                                         //mt:if %s.Field == HUDNumber
9382                                         Number uint32
9383
9384                                         //mt:if %s.Field == HUDItem
9385                                         Item uint32
9386
9387                                         //mt:if %s.Field == HUDDir
9388                                         Dir uint32
9389
9390                                         //mt:if %s.Field == HUDAlign
9391                                         Align [2]float32
9392
9393                                         //mt:if %s.Field == HUDOffset
9394                                         Offset [2]float32
9395
9396                                         //mt:if %s.Field == HUDWorldPos
9397                                         WorldPos Pos
9398
9399                                         //mt:if %s.Field == HUDSize
9400                                         Size [2]int32
9401
9402                                         //mt:if %s.Field == HUDZIndex
9403                                         ZIndex int32
9404
9405                                         //mt:if %s.Field == HUDText2
9406                                         Text2 string
9407                                 }))(obj)).Pos)[local177]
9408                                 *p = math.Float32frombits(read32(r))
9409                         }
9410                 }
9411         }
9412         if (*(*(struct {
9413                 ID HUDID
9414
9415                 Field HUDField
9416
9417                 //mt:if %s.Field == HUDPos
9418                 Pos [2]float32
9419
9420                 //mt:if %s.Field == HUDName
9421                 Name string
9422
9423                 //mt:if %s.Field == HUDScale
9424                 Scale [2]float32
9425
9426                 //mt:if %s.Field == HUDText
9427                 Text string
9428
9429                 //mt:if %s.Field == HUDNumber
9430                 Number uint32
9431
9432                 //mt:if %s.Field == HUDItem
9433                 Item uint32
9434
9435                 //mt:if %s.Field == HUDDir
9436                 Dir uint32
9437
9438                 //mt:if %s.Field == HUDAlign
9439                 Align [2]float32
9440
9441                 //mt:if %s.Field == HUDOffset
9442                 Offset [2]float32
9443
9444                 //mt:if %s.Field == HUDWorldPos
9445                 WorldPos Pos
9446
9447                 //mt:if %s.Field == HUDSize
9448                 Size [2]int32
9449
9450                 //mt:if %s.Field == HUDZIndex
9451                 ZIndex int32
9452
9453                 //mt:if %s.Field == HUDText2
9454                 Text2 string
9455         }))(obj)).Field == HUDName {
9456                 var local178 []uint8
9457                 var local179 uint16
9458                 {
9459                         p := &local179
9460                         *p = read16(r)
9461                 }
9462                 (local178) = make([]uint8, local179)
9463                 {
9464                         _, err := io.ReadFull(r, (local178)[:])
9465                         chk(err)
9466                 }
9467                 ((*(*(struct {
9468                         ID HUDID
9469
9470                         Field HUDField
9471
9472                         //mt:if %s.Field == HUDPos
9473                         Pos [2]float32
9474
9475                         //mt:if %s.Field == HUDName
9476                         Name string
9477
9478                         //mt:if %s.Field == HUDScale
9479                         Scale [2]float32
9480
9481                         //mt:if %s.Field == HUDText
9482                         Text string
9483
9484                         //mt:if %s.Field == HUDNumber
9485                         Number uint32
9486
9487                         //mt:if %s.Field == HUDItem
9488                         Item uint32
9489
9490                         //mt:if %s.Field == HUDDir
9491                         Dir uint32
9492
9493                         //mt:if %s.Field == HUDAlign
9494                         Align [2]float32
9495
9496                         //mt:if %s.Field == HUDOffset
9497                         Offset [2]float32
9498
9499                         //mt:if %s.Field == HUDWorldPos
9500                         WorldPos Pos
9501
9502                         //mt:if %s.Field == HUDSize
9503                         Size [2]int32
9504
9505                         //mt:if %s.Field == HUDZIndex
9506                         ZIndex int32
9507
9508                         //mt:if %s.Field == HUDText2
9509                         Text2 string
9510                 }))(obj)).Name) = string(local178)
9511         }
9512         if (*(*(struct {
9513                 ID HUDID
9514
9515                 Field HUDField
9516
9517                 //mt:if %s.Field == HUDPos
9518                 Pos [2]float32
9519
9520                 //mt:if %s.Field == HUDName
9521                 Name string
9522
9523                 //mt:if %s.Field == HUDScale
9524                 Scale [2]float32
9525
9526                 //mt:if %s.Field == HUDText
9527                 Text string
9528
9529                 //mt:if %s.Field == HUDNumber
9530                 Number uint32
9531
9532                 //mt:if %s.Field == HUDItem
9533                 Item uint32
9534
9535                 //mt:if %s.Field == HUDDir
9536                 Dir uint32
9537
9538                 //mt:if %s.Field == HUDAlign
9539                 Align [2]float32
9540
9541                 //mt:if %s.Field == HUDOffset
9542                 Offset [2]float32
9543
9544                 //mt:if %s.Field == HUDWorldPos
9545                 WorldPos Pos
9546
9547                 //mt:if %s.Field == HUDSize
9548                 Size [2]int32
9549
9550                 //mt:if %s.Field == HUDZIndex
9551                 ZIndex int32
9552
9553                 //mt:if %s.Field == HUDText2
9554                 Text2 string
9555         }))(obj)).Field == HUDScale {
9556                 for local180 := range (*(*(struct {
9557                         ID HUDID
9558
9559                         Field HUDField
9560
9561                         //mt:if %s.Field == HUDPos
9562                         Pos [2]float32
9563
9564                         //mt:if %s.Field == HUDName
9565                         Name string
9566
9567                         //mt:if %s.Field == HUDScale
9568                         Scale [2]float32
9569
9570                         //mt:if %s.Field == HUDText
9571                         Text string
9572
9573                         //mt:if %s.Field == HUDNumber
9574                         Number uint32
9575
9576                         //mt:if %s.Field == HUDItem
9577                         Item uint32
9578
9579                         //mt:if %s.Field == HUDDir
9580                         Dir uint32
9581
9582                         //mt:if %s.Field == HUDAlign
9583                         Align [2]float32
9584
9585                         //mt:if %s.Field == HUDOffset
9586                         Offset [2]float32
9587
9588                         //mt:if %s.Field == HUDWorldPos
9589                         WorldPos Pos
9590
9591                         //mt:if %s.Field == HUDSize
9592                         Size [2]int32
9593
9594                         //mt:if %s.Field == HUDZIndex
9595                         ZIndex int32
9596
9597                         //mt:if %s.Field == HUDText2
9598                         Text2 string
9599                 }))(obj)).Scale {
9600                         {
9601                                 p := &((*(*(struct {
9602                                         ID HUDID
9603
9604                                         Field HUDField
9605
9606                                         //mt:if %s.Field == HUDPos
9607                                         Pos [2]float32
9608
9609                                         //mt:if %s.Field == HUDName
9610                                         Name string
9611
9612                                         //mt:if %s.Field == HUDScale
9613                                         Scale [2]float32
9614
9615                                         //mt:if %s.Field == HUDText
9616                                         Text string
9617
9618                                         //mt:if %s.Field == HUDNumber
9619                                         Number uint32
9620
9621                                         //mt:if %s.Field == HUDItem
9622                                         Item uint32
9623
9624                                         //mt:if %s.Field == HUDDir
9625                                         Dir uint32
9626
9627                                         //mt:if %s.Field == HUDAlign
9628                                         Align [2]float32
9629
9630                                         //mt:if %s.Field == HUDOffset
9631                                         Offset [2]float32
9632
9633                                         //mt:if %s.Field == HUDWorldPos
9634                                         WorldPos Pos
9635
9636                                         //mt:if %s.Field == HUDSize
9637                                         Size [2]int32
9638
9639                                         //mt:if %s.Field == HUDZIndex
9640                                         ZIndex int32
9641
9642                                         //mt:if %s.Field == HUDText2
9643                                         Text2 string
9644                                 }))(obj)).Scale)[local180]
9645                                 *p = math.Float32frombits(read32(r))
9646                         }
9647                 }
9648         }
9649         if (*(*(struct {
9650                 ID HUDID
9651
9652                 Field HUDField
9653
9654                 //mt:if %s.Field == HUDPos
9655                 Pos [2]float32
9656
9657                 //mt:if %s.Field == HUDName
9658                 Name string
9659
9660                 //mt:if %s.Field == HUDScale
9661                 Scale [2]float32
9662
9663                 //mt:if %s.Field == HUDText
9664                 Text string
9665
9666                 //mt:if %s.Field == HUDNumber
9667                 Number uint32
9668
9669                 //mt:if %s.Field == HUDItem
9670                 Item uint32
9671
9672                 //mt:if %s.Field == HUDDir
9673                 Dir uint32
9674
9675                 //mt:if %s.Field == HUDAlign
9676                 Align [2]float32
9677
9678                 //mt:if %s.Field == HUDOffset
9679                 Offset [2]float32
9680
9681                 //mt:if %s.Field == HUDWorldPos
9682                 WorldPos Pos
9683
9684                 //mt:if %s.Field == HUDSize
9685                 Size [2]int32
9686
9687                 //mt:if %s.Field == HUDZIndex
9688                 ZIndex int32
9689
9690                 //mt:if %s.Field == HUDText2
9691                 Text2 string
9692         }))(obj)).Field == HUDText {
9693                 var local181 []uint8
9694                 var local182 uint16
9695                 {
9696                         p := &local182
9697                         *p = read16(r)
9698                 }
9699                 (local181) = make([]uint8, local182)
9700                 {
9701                         _, err := io.ReadFull(r, (local181)[:])
9702                         chk(err)
9703                 }
9704                 ((*(*(struct {
9705                         ID HUDID
9706
9707                         Field HUDField
9708
9709                         //mt:if %s.Field == HUDPos
9710                         Pos [2]float32
9711
9712                         //mt:if %s.Field == HUDName
9713                         Name string
9714
9715                         //mt:if %s.Field == HUDScale
9716                         Scale [2]float32
9717
9718                         //mt:if %s.Field == HUDText
9719                         Text string
9720
9721                         //mt:if %s.Field == HUDNumber
9722                         Number uint32
9723
9724                         //mt:if %s.Field == HUDItem
9725                         Item uint32
9726
9727                         //mt:if %s.Field == HUDDir
9728                         Dir uint32
9729
9730                         //mt:if %s.Field == HUDAlign
9731                         Align [2]float32
9732
9733                         //mt:if %s.Field == HUDOffset
9734                         Offset [2]float32
9735
9736                         //mt:if %s.Field == HUDWorldPos
9737                         WorldPos Pos
9738
9739                         //mt:if %s.Field == HUDSize
9740                         Size [2]int32
9741
9742                         //mt:if %s.Field == HUDZIndex
9743                         ZIndex int32
9744
9745                         //mt:if %s.Field == HUDText2
9746                         Text2 string
9747                 }))(obj)).Text) = string(local181)
9748         }
9749         if (*(*(struct {
9750                 ID HUDID
9751
9752                 Field HUDField
9753
9754                 //mt:if %s.Field == HUDPos
9755                 Pos [2]float32
9756
9757                 //mt:if %s.Field == HUDName
9758                 Name string
9759
9760                 //mt:if %s.Field == HUDScale
9761                 Scale [2]float32
9762
9763                 //mt:if %s.Field == HUDText
9764                 Text string
9765
9766                 //mt:if %s.Field == HUDNumber
9767                 Number uint32
9768
9769                 //mt:if %s.Field == HUDItem
9770                 Item uint32
9771
9772                 //mt:if %s.Field == HUDDir
9773                 Dir uint32
9774
9775                 //mt:if %s.Field == HUDAlign
9776                 Align [2]float32
9777
9778                 //mt:if %s.Field == HUDOffset
9779                 Offset [2]float32
9780
9781                 //mt:if %s.Field == HUDWorldPos
9782                 WorldPos Pos
9783
9784                 //mt:if %s.Field == HUDSize
9785                 Size [2]int32
9786
9787                 //mt:if %s.Field == HUDZIndex
9788                 ZIndex int32
9789
9790                 //mt:if %s.Field == HUDText2
9791                 Text2 string
9792         }))(obj)).Field == HUDNumber {
9793                 {
9794                         p := &(*(*(struct {
9795                                 ID HUDID
9796
9797                                 Field HUDField
9798
9799                                 //mt:if %s.Field == HUDPos
9800                                 Pos [2]float32
9801
9802                                 //mt:if %s.Field == HUDName
9803                                 Name string
9804
9805                                 //mt:if %s.Field == HUDScale
9806                                 Scale [2]float32
9807
9808                                 //mt:if %s.Field == HUDText
9809                                 Text string
9810
9811                                 //mt:if %s.Field == HUDNumber
9812                                 Number uint32
9813
9814                                 //mt:if %s.Field == HUDItem
9815                                 Item uint32
9816
9817                                 //mt:if %s.Field == HUDDir
9818                                 Dir uint32
9819
9820                                 //mt:if %s.Field == HUDAlign
9821                                 Align [2]float32
9822
9823                                 //mt:if %s.Field == HUDOffset
9824                                 Offset [2]float32
9825
9826                                 //mt:if %s.Field == HUDWorldPos
9827                                 WorldPos Pos
9828
9829                                 //mt:if %s.Field == HUDSize
9830                                 Size [2]int32
9831
9832                                 //mt:if %s.Field == HUDZIndex
9833                                 ZIndex int32
9834
9835                                 //mt:if %s.Field == HUDText2
9836                                 Text2 string
9837                         }))(obj)).Number
9838                         *p = read32(r)
9839                 }
9840         }
9841         if (*(*(struct {
9842                 ID HUDID
9843
9844                 Field HUDField
9845
9846                 //mt:if %s.Field == HUDPos
9847                 Pos [2]float32
9848
9849                 //mt:if %s.Field == HUDName
9850                 Name string
9851
9852                 //mt:if %s.Field == HUDScale
9853                 Scale [2]float32
9854
9855                 //mt:if %s.Field == HUDText
9856                 Text string
9857
9858                 //mt:if %s.Field == HUDNumber
9859                 Number uint32
9860
9861                 //mt:if %s.Field == HUDItem
9862                 Item uint32
9863
9864                 //mt:if %s.Field == HUDDir
9865                 Dir uint32
9866
9867                 //mt:if %s.Field == HUDAlign
9868                 Align [2]float32
9869
9870                 //mt:if %s.Field == HUDOffset
9871                 Offset [2]float32
9872
9873                 //mt:if %s.Field == HUDWorldPos
9874                 WorldPos Pos
9875
9876                 //mt:if %s.Field == HUDSize
9877                 Size [2]int32
9878
9879                 //mt:if %s.Field == HUDZIndex
9880                 ZIndex int32
9881
9882                 //mt:if %s.Field == HUDText2
9883                 Text2 string
9884         }))(obj)).Field == HUDItem {
9885                 {
9886                         p := &(*(*(struct {
9887                                 ID HUDID
9888
9889                                 Field HUDField
9890
9891                                 //mt:if %s.Field == HUDPos
9892                                 Pos [2]float32
9893
9894                                 //mt:if %s.Field == HUDName
9895                                 Name string
9896
9897                                 //mt:if %s.Field == HUDScale
9898                                 Scale [2]float32
9899
9900                                 //mt:if %s.Field == HUDText
9901                                 Text string
9902
9903                                 //mt:if %s.Field == HUDNumber
9904                                 Number uint32
9905
9906                                 //mt:if %s.Field == HUDItem
9907                                 Item uint32
9908
9909                                 //mt:if %s.Field == HUDDir
9910                                 Dir uint32
9911
9912                                 //mt:if %s.Field == HUDAlign
9913                                 Align [2]float32
9914
9915                                 //mt:if %s.Field == HUDOffset
9916                                 Offset [2]float32
9917
9918                                 //mt:if %s.Field == HUDWorldPos
9919                                 WorldPos Pos
9920
9921                                 //mt:if %s.Field == HUDSize
9922                                 Size [2]int32
9923
9924                                 //mt:if %s.Field == HUDZIndex
9925                                 ZIndex int32
9926
9927                                 //mt:if %s.Field == HUDText2
9928                                 Text2 string
9929                         }))(obj)).Item
9930                         *p = read32(r)
9931                 }
9932         }
9933         if (*(*(struct {
9934                 ID HUDID
9935
9936                 Field HUDField
9937
9938                 //mt:if %s.Field == HUDPos
9939                 Pos [2]float32
9940
9941                 //mt:if %s.Field == HUDName
9942                 Name string
9943
9944                 //mt:if %s.Field == HUDScale
9945                 Scale [2]float32
9946
9947                 //mt:if %s.Field == HUDText
9948                 Text string
9949
9950                 //mt:if %s.Field == HUDNumber
9951                 Number uint32
9952
9953                 //mt:if %s.Field == HUDItem
9954                 Item uint32
9955
9956                 //mt:if %s.Field == HUDDir
9957                 Dir uint32
9958
9959                 //mt:if %s.Field == HUDAlign
9960                 Align [2]float32
9961
9962                 //mt:if %s.Field == HUDOffset
9963                 Offset [2]float32
9964
9965                 //mt:if %s.Field == HUDWorldPos
9966                 WorldPos Pos
9967
9968                 //mt:if %s.Field == HUDSize
9969                 Size [2]int32
9970
9971                 //mt:if %s.Field == HUDZIndex
9972                 ZIndex int32
9973
9974                 //mt:if %s.Field == HUDText2
9975                 Text2 string
9976         }))(obj)).Field == HUDDir {
9977                 {
9978                         p := &(*(*(struct {
9979                                 ID HUDID
9980
9981                                 Field HUDField
9982
9983                                 //mt:if %s.Field == HUDPos
9984                                 Pos [2]float32
9985
9986                                 //mt:if %s.Field == HUDName
9987                                 Name string
9988
9989                                 //mt:if %s.Field == HUDScale
9990                                 Scale [2]float32
9991
9992                                 //mt:if %s.Field == HUDText
9993                                 Text string
9994
9995                                 //mt:if %s.Field == HUDNumber
9996                                 Number uint32
9997
9998                                 //mt:if %s.Field == HUDItem
9999                                 Item uint32
10000
10001                                 //mt:if %s.Field == HUDDir
10002                                 Dir uint32
10003
10004                                 //mt:if %s.Field == HUDAlign
10005                                 Align [2]float32
10006
10007                                 //mt:if %s.Field == HUDOffset
10008                                 Offset [2]float32
10009
10010                                 //mt:if %s.Field == HUDWorldPos
10011                                 WorldPos Pos
10012
10013                                 //mt:if %s.Field == HUDSize
10014                                 Size [2]int32
10015
10016                                 //mt:if %s.Field == HUDZIndex
10017                                 ZIndex int32
10018
10019                                 //mt:if %s.Field == HUDText2
10020                                 Text2 string
10021                         }))(obj)).Dir
10022                         *p = read32(r)
10023                 }
10024         }
10025         if (*(*(struct {
10026                 ID HUDID
10027
10028                 Field HUDField
10029
10030                 //mt:if %s.Field == HUDPos
10031                 Pos [2]float32
10032
10033                 //mt:if %s.Field == HUDName
10034                 Name string
10035
10036                 //mt:if %s.Field == HUDScale
10037                 Scale [2]float32
10038
10039                 //mt:if %s.Field == HUDText
10040                 Text string
10041
10042                 //mt:if %s.Field == HUDNumber
10043                 Number uint32
10044
10045                 //mt:if %s.Field == HUDItem
10046                 Item uint32
10047
10048                 //mt:if %s.Field == HUDDir
10049                 Dir uint32
10050
10051                 //mt:if %s.Field == HUDAlign
10052                 Align [2]float32
10053
10054                 //mt:if %s.Field == HUDOffset
10055                 Offset [2]float32
10056
10057                 //mt:if %s.Field == HUDWorldPos
10058                 WorldPos Pos
10059
10060                 //mt:if %s.Field == HUDSize
10061                 Size [2]int32
10062
10063                 //mt:if %s.Field == HUDZIndex
10064                 ZIndex int32
10065
10066                 //mt:if %s.Field == HUDText2
10067                 Text2 string
10068         }))(obj)).Field == HUDAlign {
10069                 for local183 := range (*(*(struct {
10070                         ID HUDID
10071
10072                         Field HUDField
10073
10074                         //mt:if %s.Field == HUDPos
10075                         Pos [2]float32
10076
10077                         //mt:if %s.Field == HUDName
10078                         Name string
10079
10080                         //mt:if %s.Field == HUDScale
10081                         Scale [2]float32
10082
10083                         //mt:if %s.Field == HUDText
10084                         Text string
10085
10086                         //mt:if %s.Field == HUDNumber
10087                         Number uint32
10088
10089                         //mt:if %s.Field == HUDItem
10090                         Item uint32
10091
10092                         //mt:if %s.Field == HUDDir
10093                         Dir uint32
10094
10095                         //mt:if %s.Field == HUDAlign
10096                         Align [2]float32
10097
10098                         //mt:if %s.Field == HUDOffset
10099                         Offset [2]float32
10100
10101                         //mt:if %s.Field == HUDWorldPos
10102                         WorldPos Pos
10103
10104                         //mt:if %s.Field == HUDSize
10105                         Size [2]int32
10106
10107                         //mt:if %s.Field == HUDZIndex
10108                         ZIndex int32
10109
10110                         //mt:if %s.Field == HUDText2
10111                         Text2 string
10112                 }))(obj)).Align {
10113                         {
10114                                 p := &((*(*(struct {
10115                                         ID HUDID
10116
10117                                         Field HUDField
10118
10119                                         //mt:if %s.Field == HUDPos
10120                                         Pos [2]float32
10121
10122                                         //mt:if %s.Field == HUDName
10123                                         Name string
10124
10125                                         //mt:if %s.Field == HUDScale
10126                                         Scale [2]float32
10127
10128                                         //mt:if %s.Field == HUDText
10129                                         Text string
10130
10131                                         //mt:if %s.Field == HUDNumber
10132                                         Number uint32
10133
10134                                         //mt:if %s.Field == HUDItem
10135                                         Item uint32
10136
10137                                         //mt:if %s.Field == HUDDir
10138                                         Dir uint32
10139
10140                                         //mt:if %s.Field == HUDAlign
10141                                         Align [2]float32
10142
10143                                         //mt:if %s.Field == HUDOffset
10144                                         Offset [2]float32
10145
10146                                         //mt:if %s.Field == HUDWorldPos
10147                                         WorldPos Pos
10148
10149                                         //mt:if %s.Field == HUDSize
10150                                         Size [2]int32
10151
10152                                         //mt:if %s.Field == HUDZIndex
10153                                         ZIndex int32
10154
10155                                         //mt:if %s.Field == HUDText2
10156                                         Text2 string
10157                                 }))(obj)).Align)[local183]
10158                                 *p = math.Float32frombits(read32(r))
10159                         }
10160                 }
10161         }
10162         if (*(*(struct {
10163                 ID HUDID
10164
10165                 Field HUDField
10166
10167                 //mt:if %s.Field == HUDPos
10168                 Pos [2]float32
10169
10170                 //mt:if %s.Field == HUDName
10171                 Name string
10172
10173                 //mt:if %s.Field == HUDScale
10174                 Scale [2]float32
10175
10176                 //mt:if %s.Field == HUDText
10177                 Text string
10178
10179                 //mt:if %s.Field == HUDNumber
10180                 Number uint32
10181
10182                 //mt:if %s.Field == HUDItem
10183                 Item uint32
10184
10185                 //mt:if %s.Field == HUDDir
10186                 Dir uint32
10187
10188                 //mt:if %s.Field == HUDAlign
10189                 Align [2]float32
10190
10191                 //mt:if %s.Field == HUDOffset
10192                 Offset [2]float32
10193
10194                 //mt:if %s.Field == HUDWorldPos
10195                 WorldPos Pos
10196
10197                 //mt:if %s.Field == HUDSize
10198                 Size [2]int32
10199
10200                 //mt:if %s.Field == HUDZIndex
10201                 ZIndex int32
10202
10203                 //mt:if %s.Field == HUDText2
10204                 Text2 string
10205         }))(obj)).Field == HUDOffset {
10206                 for local184 := range (*(*(struct {
10207                         ID HUDID
10208
10209                         Field HUDField
10210
10211                         //mt:if %s.Field == HUDPos
10212                         Pos [2]float32
10213
10214                         //mt:if %s.Field == HUDName
10215                         Name string
10216
10217                         //mt:if %s.Field == HUDScale
10218                         Scale [2]float32
10219
10220                         //mt:if %s.Field == HUDText
10221                         Text string
10222
10223                         //mt:if %s.Field == HUDNumber
10224                         Number uint32
10225
10226                         //mt:if %s.Field == HUDItem
10227                         Item uint32
10228
10229                         //mt:if %s.Field == HUDDir
10230                         Dir uint32
10231
10232                         //mt:if %s.Field == HUDAlign
10233                         Align [2]float32
10234
10235                         //mt:if %s.Field == HUDOffset
10236                         Offset [2]float32
10237
10238                         //mt:if %s.Field == HUDWorldPos
10239                         WorldPos Pos
10240
10241                         //mt:if %s.Field == HUDSize
10242                         Size [2]int32
10243
10244                         //mt:if %s.Field == HUDZIndex
10245                         ZIndex int32
10246
10247                         //mt:if %s.Field == HUDText2
10248                         Text2 string
10249                 }))(obj)).Offset {
10250                         {
10251                                 p := &((*(*(struct {
10252                                         ID HUDID
10253
10254                                         Field HUDField
10255
10256                                         //mt:if %s.Field == HUDPos
10257                                         Pos [2]float32
10258
10259                                         //mt:if %s.Field == HUDName
10260                                         Name string
10261
10262                                         //mt:if %s.Field == HUDScale
10263                                         Scale [2]float32
10264
10265                                         //mt:if %s.Field == HUDText
10266                                         Text string
10267
10268                                         //mt:if %s.Field == HUDNumber
10269                                         Number uint32
10270
10271                                         //mt:if %s.Field == HUDItem
10272                                         Item uint32
10273
10274                                         //mt:if %s.Field == HUDDir
10275                                         Dir uint32
10276
10277                                         //mt:if %s.Field == HUDAlign
10278                                         Align [2]float32
10279
10280                                         //mt:if %s.Field == HUDOffset
10281                                         Offset [2]float32
10282
10283                                         //mt:if %s.Field == HUDWorldPos
10284                                         WorldPos Pos
10285
10286                                         //mt:if %s.Field == HUDSize
10287                                         Size [2]int32
10288
10289                                         //mt:if %s.Field == HUDZIndex
10290                                         ZIndex int32
10291
10292                                         //mt:if %s.Field == HUDText2
10293                                         Text2 string
10294                                 }))(obj)).Offset)[local184]
10295                                 *p = math.Float32frombits(read32(r))
10296                         }
10297                 }
10298         }
10299         if (*(*(struct {
10300                 ID HUDID
10301
10302                 Field HUDField
10303
10304                 //mt:if %s.Field == HUDPos
10305                 Pos [2]float32
10306
10307                 //mt:if %s.Field == HUDName
10308                 Name string
10309
10310                 //mt:if %s.Field == HUDScale
10311                 Scale [2]float32
10312
10313                 //mt:if %s.Field == HUDText
10314                 Text string
10315
10316                 //mt:if %s.Field == HUDNumber
10317                 Number uint32
10318
10319                 //mt:if %s.Field == HUDItem
10320                 Item uint32
10321
10322                 //mt:if %s.Field == HUDDir
10323                 Dir uint32
10324
10325                 //mt:if %s.Field == HUDAlign
10326                 Align [2]float32
10327
10328                 //mt:if %s.Field == HUDOffset
10329                 Offset [2]float32
10330
10331                 //mt:if %s.Field == HUDWorldPos
10332                 WorldPos Pos
10333
10334                 //mt:if %s.Field == HUDSize
10335                 Size [2]int32
10336
10337                 //mt:if %s.Field == HUDZIndex
10338                 ZIndex int32
10339
10340                 //mt:if %s.Field == HUDText2
10341                 Text2 string
10342         }))(obj)).Field == HUDWorldPos {
10343                 if err := pcall(func() {
10344                         ((*(*(struct {
10345                                 ID HUDID
10346
10347                                 Field HUDField
10348
10349                                 //mt:if %s.Field == HUDPos
10350                                 Pos [2]float32
10351
10352                                 //mt:if %s.Field == HUDName
10353                                 Name string
10354
10355                                 //mt:if %s.Field == HUDScale
10356                                 Scale [2]float32
10357
10358                                 //mt:if %s.Field == HUDText
10359                                 Text string
10360
10361                                 //mt:if %s.Field == HUDNumber
10362                                 Number uint32
10363
10364                                 //mt:if %s.Field == HUDItem
10365                                 Item uint32
10366
10367                                 //mt:if %s.Field == HUDDir
10368                                 Dir uint32
10369
10370                                 //mt:if %s.Field == HUDAlign
10371                                 Align [2]float32
10372
10373                                 //mt:if %s.Field == HUDOffset
10374                                 Offset [2]float32
10375
10376                                 //mt:if %s.Field == HUDWorldPos
10377                                 WorldPos Pos
10378
10379                                 //mt:if %s.Field == HUDSize
10380                                 Size [2]int32
10381
10382                                 //mt:if %s.Field == HUDZIndex
10383                                 ZIndex int32
10384
10385                                 //mt:if %s.Field == HUDText2
10386                                 Text2 string
10387                         }))(obj)).WorldPos).deserialize(r)
10388                 }); err != nil {
10389                         if err == io.EOF {
10390                                 chk(io.EOF)
10391                         }
10392                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
10393                 }
10394         }
10395         if (*(*(struct {
10396                 ID HUDID
10397
10398                 Field HUDField
10399
10400                 //mt:if %s.Field == HUDPos
10401                 Pos [2]float32
10402
10403                 //mt:if %s.Field == HUDName
10404                 Name string
10405
10406                 //mt:if %s.Field == HUDScale
10407                 Scale [2]float32
10408
10409                 //mt:if %s.Field == HUDText
10410                 Text string
10411
10412                 //mt:if %s.Field == HUDNumber
10413                 Number uint32
10414
10415                 //mt:if %s.Field == HUDItem
10416                 Item uint32
10417
10418                 //mt:if %s.Field == HUDDir
10419                 Dir uint32
10420
10421                 //mt:if %s.Field == HUDAlign
10422                 Align [2]float32
10423
10424                 //mt:if %s.Field == HUDOffset
10425                 Offset [2]float32
10426
10427                 //mt:if %s.Field == HUDWorldPos
10428                 WorldPos Pos
10429
10430                 //mt:if %s.Field == HUDSize
10431                 Size [2]int32
10432
10433                 //mt:if %s.Field == HUDZIndex
10434                 ZIndex int32
10435
10436                 //mt:if %s.Field == HUDText2
10437                 Text2 string
10438         }))(obj)).Field == HUDSize {
10439                 for local185 := range (*(*(struct {
10440                         ID HUDID
10441
10442                         Field HUDField
10443
10444                         //mt:if %s.Field == HUDPos
10445                         Pos [2]float32
10446
10447                         //mt:if %s.Field == HUDName
10448                         Name string
10449
10450                         //mt:if %s.Field == HUDScale
10451                         Scale [2]float32
10452
10453                         //mt:if %s.Field == HUDText
10454                         Text string
10455
10456                         //mt:if %s.Field == HUDNumber
10457                         Number uint32
10458
10459                         //mt:if %s.Field == HUDItem
10460                         Item uint32
10461
10462                         //mt:if %s.Field == HUDDir
10463                         Dir uint32
10464
10465                         //mt:if %s.Field == HUDAlign
10466                         Align [2]float32
10467
10468                         //mt:if %s.Field == HUDOffset
10469                         Offset [2]float32
10470
10471                         //mt:if %s.Field == HUDWorldPos
10472                         WorldPos Pos
10473
10474                         //mt:if %s.Field == HUDSize
10475                         Size [2]int32
10476
10477                         //mt:if %s.Field == HUDZIndex
10478                         ZIndex int32
10479
10480                         //mt:if %s.Field == HUDText2
10481                         Text2 string
10482                 }))(obj)).Size {
10483                         {
10484                                 p := &((*(*(struct {
10485                                         ID HUDID
10486
10487                                         Field HUDField
10488
10489                                         //mt:if %s.Field == HUDPos
10490                                         Pos [2]float32
10491
10492                                         //mt:if %s.Field == HUDName
10493                                         Name string
10494
10495                                         //mt:if %s.Field == HUDScale
10496                                         Scale [2]float32
10497
10498                                         //mt:if %s.Field == HUDText
10499                                         Text string
10500
10501                                         //mt:if %s.Field == HUDNumber
10502                                         Number uint32
10503
10504                                         //mt:if %s.Field == HUDItem
10505                                         Item uint32
10506
10507                                         //mt:if %s.Field == HUDDir
10508                                         Dir uint32
10509
10510                                         //mt:if %s.Field == HUDAlign
10511                                         Align [2]float32
10512
10513                                         //mt:if %s.Field == HUDOffset
10514                                         Offset [2]float32
10515
10516                                         //mt:if %s.Field == HUDWorldPos
10517                                         WorldPos Pos
10518
10519                                         //mt:if %s.Field == HUDSize
10520                                         Size [2]int32
10521
10522                                         //mt:if %s.Field == HUDZIndex
10523                                         ZIndex int32
10524
10525                                         //mt:if %s.Field == HUDText2
10526                                         Text2 string
10527                                 }))(obj)).Size)[local185]
10528                                 *p = int32(read32(r))
10529                         }
10530                 }
10531         }
10532         if (*(*(struct {
10533                 ID HUDID
10534
10535                 Field HUDField
10536
10537                 //mt:if %s.Field == HUDPos
10538                 Pos [2]float32
10539
10540                 //mt:if %s.Field == HUDName
10541                 Name string
10542
10543                 //mt:if %s.Field == HUDScale
10544                 Scale [2]float32
10545
10546                 //mt:if %s.Field == HUDText
10547                 Text string
10548
10549                 //mt:if %s.Field == HUDNumber
10550                 Number uint32
10551
10552                 //mt:if %s.Field == HUDItem
10553                 Item uint32
10554
10555                 //mt:if %s.Field == HUDDir
10556                 Dir uint32
10557
10558                 //mt:if %s.Field == HUDAlign
10559                 Align [2]float32
10560
10561                 //mt:if %s.Field == HUDOffset
10562                 Offset [2]float32
10563
10564                 //mt:if %s.Field == HUDWorldPos
10565                 WorldPos Pos
10566
10567                 //mt:if %s.Field == HUDSize
10568                 Size [2]int32
10569
10570                 //mt:if %s.Field == HUDZIndex
10571                 ZIndex int32
10572
10573                 //mt:if %s.Field == HUDText2
10574                 Text2 string
10575         }))(obj)).Field == HUDZIndex {
10576                 {
10577                         p := &(*(*(struct {
10578                                 ID HUDID
10579
10580                                 Field HUDField
10581
10582                                 //mt:if %s.Field == HUDPos
10583                                 Pos [2]float32
10584
10585                                 //mt:if %s.Field == HUDName
10586                                 Name string
10587
10588                                 //mt:if %s.Field == HUDScale
10589                                 Scale [2]float32
10590
10591                                 //mt:if %s.Field == HUDText
10592                                 Text string
10593
10594                                 //mt:if %s.Field == HUDNumber
10595                                 Number uint32
10596
10597                                 //mt:if %s.Field == HUDItem
10598                                 Item uint32
10599
10600                                 //mt:if %s.Field == HUDDir
10601                                 Dir uint32
10602
10603                                 //mt:if %s.Field == HUDAlign
10604                                 Align [2]float32
10605
10606                                 //mt:if %s.Field == HUDOffset
10607                                 Offset [2]float32
10608
10609                                 //mt:if %s.Field == HUDWorldPos
10610                                 WorldPos Pos
10611
10612                                 //mt:if %s.Field == HUDSize
10613                                 Size [2]int32
10614
10615                                 //mt:if %s.Field == HUDZIndex
10616                                 ZIndex int32
10617
10618                                 //mt:if %s.Field == HUDText2
10619                                 Text2 string
10620                         }))(obj)).ZIndex
10621                         *p = int32(read32(r))
10622                 }
10623         }
10624         if (*(*(struct {
10625                 ID HUDID
10626
10627                 Field HUDField
10628
10629                 //mt:if %s.Field == HUDPos
10630                 Pos [2]float32
10631
10632                 //mt:if %s.Field == HUDName
10633                 Name string
10634
10635                 //mt:if %s.Field == HUDScale
10636                 Scale [2]float32
10637
10638                 //mt:if %s.Field == HUDText
10639                 Text string
10640
10641                 //mt:if %s.Field == HUDNumber
10642                 Number uint32
10643
10644                 //mt:if %s.Field == HUDItem
10645                 Item uint32
10646
10647                 //mt:if %s.Field == HUDDir
10648                 Dir uint32
10649
10650                 //mt:if %s.Field == HUDAlign
10651                 Align [2]float32
10652
10653                 //mt:if %s.Field == HUDOffset
10654                 Offset [2]float32
10655
10656                 //mt:if %s.Field == HUDWorldPos
10657                 WorldPos Pos
10658
10659                 //mt:if %s.Field == HUDSize
10660                 Size [2]int32
10661
10662                 //mt:if %s.Field == HUDZIndex
10663                 ZIndex int32
10664
10665                 //mt:if %s.Field == HUDText2
10666                 Text2 string
10667         }))(obj)).Field == HUDText2 {
10668                 var local186 []uint8
10669                 var local187 uint16
10670                 {
10671                         p := &local187
10672                         *p = read16(r)
10673                 }
10674                 (local186) = make([]uint8, local187)
10675                 {
10676                         _, err := io.ReadFull(r, (local186)[:])
10677                         chk(err)
10678                 }
10679                 ((*(*(struct {
10680                         ID HUDID
10681
10682                         Field HUDField
10683
10684                         //mt:if %s.Field == HUDPos
10685                         Pos [2]float32
10686
10687                         //mt:if %s.Field == HUDName
10688                         Name string
10689
10690                         //mt:if %s.Field == HUDScale
10691                         Scale [2]float32
10692
10693                         //mt:if %s.Field == HUDText
10694                         Text string
10695
10696                         //mt:if %s.Field == HUDNumber
10697                         Number uint32
10698
10699                         //mt:if %s.Field == HUDItem
10700                         Item uint32
10701
10702                         //mt:if %s.Field == HUDDir
10703                         Dir uint32
10704
10705                         //mt:if %s.Field == HUDAlign
10706                         Align [2]float32
10707
10708                         //mt:if %s.Field == HUDOffset
10709                         Offset [2]float32
10710
10711                         //mt:if %s.Field == HUDWorldPos
10712                         WorldPos Pos
10713
10714                         //mt:if %s.Field == HUDSize
10715                         Size [2]int32
10716
10717                         //mt:if %s.Field == HUDZIndex
10718                         ZIndex int32
10719
10720                         //mt:if %s.Field == HUDText2
10721                         Text2 string
10722                 }))(obj)).Text2) = string(local186)
10723         }
10724 }
10725
10726 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
10727         if err := pcall(func() {
10728                 ((*(*(struct {
10729                         // &^= Mask
10730                         // |= Flags
10731                         Flags, Mask HUDFlags
10732                 }))(obj)).Flags).serialize(w)
10733         }); err != nil {
10734                 if err == io.EOF {
10735                         chk(io.EOF)
10736                 }
10737                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10738         }
10739         if err := pcall(func() {
10740                 ((*(*(struct {
10741                         // &^= Mask
10742                         // |= Flags
10743                         Flags, Mask HUDFlags
10744                 }))(obj)).Mask).serialize(w)
10745         }); err != nil {
10746                 if err == io.EOF {
10747                         chk(io.EOF)
10748                 }
10749                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10750         }
10751 }
10752
10753 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
10754         if err := pcall(func() {
10755                 ((*(*(struct {
10756                         // &^= Mask
10757                         // |= Flags
10758                         Flags, Mask HUDFlags
10759                 }))(obj)).Flags).deserialize(r)
10760         }); err != nil {
10761                 if err == io.EOF {
10762                         chk(io.EOF)
10763                 }
10764                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10765         }
10766         if err := pcall(func() {
10767                 ((*(*(struct {
10768                         // &^= Mask
10769                         // |= Flags
10770                         Flags, Mask HUDFlags
10771                 }))(obj)).Mask).deserialize(r)
10772         }); err != nil {
10773                 if err == io.EOF {
10774                         chk(io.EOF)
10775                 }
10776                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10777         }
10778 }
10779
10780 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
10781         if err := pcall(func() {
10782                 ((*(*(struct {
10783                         Param HotbarParam
10784
10785                         //mt:if %s.Param == HotbarSize
10786                         //mt:const uint16(4) // Size of Size field.
10787                         Size int32
10788
10789                         //mt:if %s.Param != HotbarSize
10790                         Img Texture
10791                 }))(obj)).Param).serialize(w)
10792         }); err != nil {
10793                 if err == io.EOF {
10794                         chk(io.EOF)
10795                 }
10796                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HotbarParam", err))
10797         }
10798         if (*(*(struct {
10799                 Param HotbarParam
10800
10801                 //mt:if %s.Param == HotbarSize
10802                 //mt:const uint16(4) // Size of Size field.
10803                 Size int32
10804
10805                 //mt:if %s.Param != HotbarSize
10806                 Img Texture
10807         }))(obj)).Param == HotbarSize {
10808                 {
10809                         local188 := uint16(4) // Size of Size field.
10810                         {
10811                                 x := local188
10812                                 write16(w, uint16(x))
10813                         }
10814                 }
10815                 {
10816                         x := (*(*(struct {
10817                                 Param HotbarParam
10818
10819                                 //mt:if %s.Param == HotbarSize
10820                                 //mt:const uint16(4) // Size of Size field.
10821                                 Size int32
10822
10823                                 //mt:if %s.Param != HotbarSize
10824                                 Img Texture
10825                         }))(obj)).Size
10826                         write32(w, uint32(x))
10827                 }
10828         }
10829         if (*(*(struct {
10830                 Param HotbarParam
10831
10832                 //mt:if %s.Param == HotbarSize
10833                 //mt:const uint16(4) // Size of Size field.
10834                 Size int32
10835
10836                 //mt:if %s.Param != HotbarSize
10837                 Img Texture
10838         }))(obj)).Param != HotbarSize {
10839                 if err := pcall(func() {
10840                         ((*(*(struct {
10841                                 Param HotbarParam
10842
10843                                 //mt:if %s.Param == HotbarSize
10844                                 //mt:const uint16(4) // Size of Size field.
10845                                 Size int32
10846
10847                                 //mt:if %s.Param != HotbarSize
10848                                 Img Texture
10849                         }))(obj)).Img).serialize(w)
10850                 }); err != nil {
10851                         if err == io.EOF {
10852                                 chk(io.EOF)
10853                         }
10854                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
10855                 }
10856         }
10857 }
10858
10859 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
10860         if err := pcall(func() {
10861                 ((*(*(struct {
10862                         Param HotbarParam
10863
10864                         //mt:if %s.Param == HotbarSize
10865                         //mt:const uint16(4) // Size of Size field.
10866                         Size int32
10867
10868                         //mt:if %s.Param != HotbarSize
10869                         Img Texture
10870                 }))(obj)).Param).deserialize(r)
10871         }); err != nil {
10872                 if err == io.EOF {
10873                         chk(io.EOF)
10874                 }
10875                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HotbarParam", err))
10876         }
10877         if (*(*(struct {
10878                 Param HotbarParam
10879
10880                 //mt:if %s.Param == HotbarSize
10881                 //mt:const uint16(4) // Size of Size field.
10882                 Size int32
10883
10884                 //mt:if %s.Param != HotbarSize
10885                 Img Texture
10886         }))(obj)).Param == HotbarSize {
10887                 {
10888                         var local189 uint16
10889                         local190 := uint16(4) // Size of Size field.
10890                         {
10891                                 p := &local189
10892                                 *p = read16(r)
10893                         }
10894                         if local189 != local190 {
10895                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
10896                         }
10897                 }
10898                 {
10899                         p := &(*(*(struct {
10900                                 Param HotbarParam
10901
10902                                 //mt:if %s.Param == HotbarSize
10903                                 //mt:const uint16(4) // Size of Size field.
10904                                 Size int32
10905
10906                                 //mt:if %s.Param != HotbarSize
10907                                 Img Texture
10908                         }))(obj)).Size
10909                         *p = int32(read32(r))
10910                 }
10911         }
10912         if (*(*(struct {
10913                 Param HotbarParam
10914
10915                 //mt:if %s.Param == HotbarSize
10916                 //mt:const uint16(4) // Size of Size field.
10917                 Size int32
10918
10919                 //mt:if %s.Param != HotbarSize
10920                 Img Texture
10921         }))(obj)).Param != HotbarSize {
10922                 if err := pcall(func() {
10923                         ((*(*(struct {
10924                                 Param HotbarParam
10925
10926                                 //mt:if %s.Param == HotbarSize
10927                                 //mt:const uint16(4) // Size of Size field.
10928                                 Size int32
10929
10930                                 //mt:if %s.Param != HotbarSize
10931                                 Img Texture
10932                         }))(obj)).Img).deserialize(r)
10933                 }); err != nil {
10934                         if err == io.EOF {
10935                                 chk(io.EOF)
10936                         }
10937                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
10938                 }
10939         }
10940 }
10941
10942 func (obj *ToCltBreath) serialize(w io.Writer) {
10943         {
10944                 x := (*(*(struct {
10945                         Breath uint16
10946                 }))(obj)).Breath
10947                 write16(w, uint16(x))
10948         }
10949 }
10950
10951 func (obj *ToCltBreath) deserialize(r io.Reader) {
10952         {
10953                 p := &(*(*(struct {
10954                         Breath uint16
10955                 }))(obj)).Breath
10956                 *p = read16(r)
10957         }
10958 }
10959
10960 func (obj *ToCltSkyParams) serialize(w io.Writer) {
10961         {
10962                 x := (*(*(struct {
10963                         BgColor     color.NRGBA
10964                         Type        string
10965                         Clouds      bool
10966                         SunFogTint  color.NRGBA
10967                         MoonFogTint color.NRGBA
10968                         FogTintType string
10969
10970                         //mt:if %s.Type == "skybox"
10971                         Textures []Texture
10972
10973                         //mt:if %s.Type == "regular"
10974                         DaySky, DayHorizon,
10975                         DawnSky, DawnHorizon,
10976                         NightSky, NightHorizon,
10977                         Indoor color.NRGBA
10978                 }))(obj)).BgColor
10979                 w.Write([]byte{x.A, x.R, x.G, x.B})
10980         }
10981         if len(([]byte((*(*(struct {
10982                 BgColor     color.NRGBA
10983                 Type        string
10984                 Clouds      bool
10985                 SunFogTint  color.NRGBA
10986                 MoonFogTint color.NRGBA
10987                 FogTintType string
10988
10989                 //mt:if %s.Type == "skybox"
10990                 Textures []Texture
10991
10992                 //mt:if %s.Type == "regular"
10993                 DaySky, DayHorizon,
10994                 DawnSky, DawnHorizon,
10995                 NightSky, NightHorizon,
10996                 Indoor color.NRGBA
10997         }))(obj)).Type))) > math.MaxUint16 {
10998                 chk(ErrTooLong)
10999         }
11000         {
11001                 x := uint16(len(([]byte((*(*(struct {
11002                         BgColor     color.NRGBA
11003                         Type        string
11004                         Clouds      bool
11005                         SunFogTint  color.NRGBA
11006                         MoonFogTint color.NRGBA
11007                         FogTintType string
11008
11009                         //mt:if %s.Type == "skybox"
11010                         Textures []Texture
11011
11012                         //mt:if %s.Type == "regular"
11013                         DaySky, DayHorizon,
11014                         DawnSky, DawnHorizon,
11015                         NightSky, NightHorizon,
11016                         Indoor color.NRGBA
11017                 }))(obj)).Type))))
11018                 write16(w, uint16(x))
11019         }
11020         {
11021                 _, err := w.Write(([]byte((*(*(struct {
11022                         BgColor     color.NRGBA
11023                         Type        string
11024                         Clouds      bool
11025                         SunFogTint  color.NRGBA
11026                         MoonFogTint color.NRGBA
11027                         FogTintType string
11028
11029                         //mt:if %s.Type == "skybox"
11030                         Textures []Texture
11031
11032                         //mt:if %s.Type == "regular"
11033                         DaySky, DayHorizon,
11034                         DawnSky, DawnHorizon,
11035                         NightSky, NightHorizon,
11036                         Indoor color.NRGBA
11037                 }))(obj)).Type))[:])
11038                 chk(err)
11039         }
11040         {
11041                 x := (*(*(struct {
11042                         BgColor     color.NRGBA
11043                         Type        string
11044                         Clouds      bool
11045                         SunFogTint  color.NRGBA
11046                         MoonFogTint color.NRGBA
11047                         FogTintType string
11048
11049                         //mt:if %s.Type == "skybox"
11050                         Textures []Texture
11051
11052                         //mt:if %s.Type == "regular"
11053                         DaySky, DayHorizon,
11054                         DawnSky, DawnHorizon,
11055                         NightSky, NightHorizon,
11056                         Indoor color.NRGBA
11057                 }))(obj)).Clouds
11058                 if x {
11059                         write8(w, 1)
11060                 } else {
11061                         write8(w, 0)
11062                 }
11063         }
11064         {
11065                 x := (*(*(struct {
11066                         BgColor     color.NRGBA
11067                         Type        string
11068                         Clouds      bool
11069                         SunFogTint  color.NRGBA
11070                         MoonFogTint color.NRGBA
11071                         FogTintType string
11072
11073                         //mt:if %s.Type == "skybox"
11074                         Textures []Texture
11075
11076                         //mt:if %s.Type == "regular"
11077                         DaySky, DayHorizon,
11078                         DawnSky, DawnHorizon,
11079                         NightSky, NightHorizon,
11080                         Indoor color.NRGBA
11081                 }))(obj)).SunFogTint
11082                 w.Write([]byte{x.A, x.R, x.G, x.B})
11083         }
11084         {
11085                 x := (*(*(struct {
11086                         BgColor     color.NRGBA
11087                         Type        string
11088                         Clouds      bool
11089                         SunFogTint  color.NRGBA
11090                         MoonFogTint color.NRGBA
11091                         FogTintType string
11092
11093                         //mt:if %s.Type == "skybox"
11094                         Textures []Texture
11095
11096                         //mt:if %s.Type == "regular"
11097                         DaySky, DayHorizon,
11098                         DawnSky, DawnHorizon,
11099                         NightSky, NightHorizon,
11100                         Indoor color.NRGBA
11101                 }))(obj)).MoonFogTint
11102                 w.Write([]byte{x.A, x.R, x.G, x.B})
11103         }
11104         if len(([]byte((*(*(struct {
11105                 BgColor     color.NRGBA
11106                 Type        string
11107                 Clouds      bool
11108                 SunFogTint  color.NRGBA
11109                 MoonFogTint color.NRGBA
11110                 FogTintType string
11111
11112                 //mt:if %s.Type == "skybox"
11113                 Textures []Texture
11114
11115                 //mt:if %s.Type == "regular"
11116                 DaySky, DayHorizon,
11117                 DawnSky, DawnHorizon,
11118                 NightSky, NightHorizon,
11119                 Indoor color.NRGBA
11120         }))(obj)).FogTintType))) > math.MaxUint16 {
11121                 chk(ErrTooLong)
11122         }
11123         {
11124                 x := uint16(len(([]byte((*(*(struct {
11125                         BgColor     color.NRGBA
11126                         Type        string
11127                         Clouds      bool
11128                         SunFogTint  color.NRGBA
11129                         MoonFogTint color.NRGBA
11130                         FogTintType string
11131
11132                         //mt:if %s.Type == "skybox"
11133                         Textures []Texture
11134
11135                         //mt:if %s.Type == "regular"
11136                         DaySky, DayHorizon,
11137                         DawnSky, DawnHorizon,
11138                         NightSky, NightHorizon,
11139                         Indoor color.NRGBA
11140                 }))(obj)).FogTintType))))
11141                 write16(w, uint16(x))
11142         }
11143         {
11144                 _, err := w.Write(([]byte((*(*(struct {
11145                         BgColor     color.NRGBA
11146                         Type        string
11147                         Clouds      bool
11148                         SunFogTint  color.NRGBA
11149                         MoonFogTint color.NRGBA
11150                         FogTintType string
11151
11152                         //mt:if %s.Type == "skybox"
11153                         Textures []Texture
11154
11155                         //mt:if %s.Type == "regular"
11156                         DaySky, DayHorizon,
11157                         DawnSky, DawnHorizon,
11158                         NightSky, NightHorizon,
11159                         Indoor color.NRGBA
11160                 }))(obj)).FogTintType))[:])
11161                 chk(err)
11162         }
11163         if (*(*(struct {
11164                 BgColor     color.NRGBA
11165                 Type        string
11166                 Clouds      bool
11167                 SunFogTint  color.NRGBA
11168                 MoonFogTint color.NRGBA
11169                 FogTintType string
11170
11171                 //mt:if %s.Type == "skybox"
11172                 Textures []Texture
11173
11174                 //mt:if %s.Type == "regular"
11175                 DaySky, DayHorizon,
11176                 DawnSky, DawnHorizon,
11177                 NightSky, NightHorizon,
11178                 Indoor color.NRGBA
11179         }))(obj)).Type == "skybox" {
11180                 if len(((*(*(struct {
11181                         BgColor     color.NRGBA
11182                         Type        string
11183                         Clouds      bool
11184                         SunFogTint  color.NRGBA
11185                         MoonFogTint color.NRGBA
11186                         FogTintType string
11187
11188                         //mt:if %s.Type == "skybox"
11189                         Textures []Texture
11190
11191                         //mt:if %s.Type == "regular"
11192                         DaySky, DayHorizon,
11193                         DawnSky, DawnHorizon,
11194                         NightSky, NightHorizon,
11195                         Indoor color.NRGBA
11196                 }))(obj)).Textures)) > math.MaxUint16 {
11197                         chk(ErrTooLong)
11198                 }
11199                 {
11200                         x := uint16(len(((*(*(struct {
11201                                 BgColor     color.NRGBA
11202                                 Type        string
11203                                 Clouds      bool
11204                                 SunFogTint  color.NRGBA
11205                                 MoonFogTint color.NRGBA
11206                                 FogTintType string
11207
11208                                 //mt:if %s.Type == "skybox"
11209                                 Textures []Texture
11210
11211                                 //mt:if %s.Type == "regular"
11212                                 DaySky, DayHorizon,
11213                                 DawnSky, DawnHorizon,
11214                                 NightSky, NightHorizon,
11215                                 Indoor color.NRGBA
11216                         }))(obj)).Textures)))
11217                         write16(w, uint16(x))
11218                 }
11219                 for local191 := range (*(*(struct {
11220                         BgColor     color.NRGBA
11221                         Type        string
11222                         Clouds      bool
11223                         SunFogTint  color.NRGBA
11224                         MoonFogTint color.NRGBA
11225                         FogTintType string
11226
11227                         //mt:if %s.Type == "skybox"
11228                         Textures []Texture
11229
11230                         //mt:if %s.Type == "regular"
11231                         DaySky, DayHorizon,
11232                         DawnSky, DawnHorizon,
11233                         NightSky, NightHorizon,
11234                         Indoor color.NRGBA
11235                 }))(obj)).Textures {
11236                         if err := pcall(func() {
11237                                 (((*(*(struct {
11238                                         BgColor     color.NRGBA
11239                                         Type        string
11240                                         Clouds      bool
11241                                         SunFogTint  color.NRGBA
11242                                         MoonFogTint color.NRGBA
11243                                         FogTintType string
11244
11245                                         //mt:if %s.Type == "skybox"
11246                                         Textures []Texture
11247
11248                                         //mt:if %s.Type == "regular"
11249                                         DaySky, DayHorizon,
11250                                         DawnSky, DawnHorizon,
11251                                         NightSky, NightHorizon,
11252                                         Indoor color.NRGBA
11253                                 }))(obj)).Textures)[local191]).serialize(w)
11254                         }); err != nil {
11255                                 if err == io.EOF {
11256                                         chk(io.EOF)
11257                                 }
11258                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
11259                         }
11260                 }
11261         }
11262         if (*(*(struct {
11263                 BgColor     color.NRGBA
11264                 Type        string
11265                 Clouds      bool
11266                 SunFogTint  color.NRGBA
11267                 MoonFogTint color.NRGBA
11268                 FogTintType string
11269
11270                 //mt:if %s.Type == "skybox"
11271                 Textures []Texture
11272
11273                 //mt:if %s.Type == "regular"
11274                 DaySky, DayHorizon,
11275                 DawnSky, DawnHorizon,
11276                 NightSky, NightHorizon,
11277                 Indoor color.NRGBA
11278         }))(obj)).Type == "regular" {
11279                 {
11280                         x := (*(*(struct {
11281                                 BgColor     color.NRGBA
11282                                 Type        string
11283                                 Clouds      bool
11284                                 SunFogTint  color.NRGBA
11285                                 MoonFogTint color.NRGBA
11286                                 FogTintType string
11287
11288                                 //mt:if %s.Type == "skybox"
11289                                 Textures []Texture
11290
11291                                 //mt:if %s.Type == "regular"
11292                                 DaySky, DayHorizon,
11293                                 DawnSky, DawnHorizon,
11294                                 NightSky, NightHorizon,
11295                                 Indoor color.NRGBA
11296                         }))(obj)).DaySky
11297                         w.Write([]byte{x.A, x.R, x.G, x.B})
11298                 }
11299                 {
11300                         x := (*(*(struct {
11301                                 BgColor     color.NRGBA
11302                                 Type        string
11303                                 Clouds      bool
11304                                 SunFogTint  color.NRGBA
11305                                 MoonFogTint color.NRGBA
11306                                 FogTintType string
11307
11308                                 //mt:if %s.Type == "skybox"
11309                                 Textures []Texture
11310
11311                                 //mt:if %s.Type == "regular"
11312                                 DaySky, DayHorizon,
11313                                 DawnSky, DawnHorizon,
11314                                 NightSky, NightHorizon,
11315                                 Indoor color.NRGBA
11316                         }))(obj)).DayHorizon
11317                         w.Write([]byte{x.A, x.R, x.G, x.B})
11318                 }
11319                 {
11320                         x := (*(*(struct {
11321                                 BgColor     color.NRGBA
11322                                 Type        string
11323                                 Clouds      bool
11324                                 SunFogTint  color.NRGBA
11325                                 MoonFogTint color.NRGBA
11326                                 FogTintType string
11327
11328                                 //mt:if %s.Type == "skybox"
11329                                 Textures []Texture
11330
11331                                 //mt:if %s.Type == "regular"
11332                                 DaySky, DayHorizon,
11333                                 DawnSky, DawnHorizon,
11334                                 NightSky, NightHorizon,
11335                                 Indoor color.NRGBA
11336                         }))(obj)).DawnSky
11337                         w.Write([]byte{x.A, x.R, x.G, x.B})
11338                 }
11339                 {
11340                         x := (*(*(struct {
11341                                 BgColor     color.NRGBA
11342                                 Type        string
11343                                 Clouds      bool
11344                                 SunFogTint  color.NRGBA
11345                                 MoonFogTint color.NRGBA
11346                                 FogTintType string
11347
11348                                 //mt:if %s.Type == "skybox"
11349                                 Textures []Texture
11350
11351                                 //mt:if %s.Type == "regular"
11352                                 DaySky, DayHorizon,
11353                                 DawnSky, DawnHorizon,
11354                                 NightSky, NightHorizon,
11355                                 Indoor color.NRGBA
11356                         }))(obj)).DawnHorizon
11357                         w.Write([]byte{x.A, x.R, x.G, x.B})
11358                 }
11359                 {
11360                         x := (*(*(struct {
11361                                 BgColor     color.NRGBA
11362                                 Type        string
11363                                 Clouds      bool
11364                                 SunFogTint  color.NRGBA
11365                                 MoonFogTint color.NRGBA
11366                                 FogTintType string
11367
11368                                 //mt:if %s.Type == "skybox"
11369                                 Textures []Texture
11370
11371                                 //mt:if %s.Type == "regular"
11372                                 DaySky, DayHorizon,
11373                                 DawnSky, DawnHorizon,
11374                                 NightSky, NightHorizon,
11375                                 Indoor color.NRGBA
11376                         }))(obj)).NightSky
11377                         w.Write([]byte{x.A, x.R, x.G, x.B})
11378                 }
11379                 {
11380                         x := (*(*(struct {
11381                                 BgColor     color.NRGBA
11382                                 Type        string
11383                                 Clouds      bool
11384                                 SunFogTint  color.NRGBA
11385                                 MoonFogTint color.NRGBA
11386                                 FogTintType string
11387
11388                                 //mt:if %s.Type == "skybox"
11389                                 Textures []Texture
11390
11391                                 //mt:if %s.Type == "regular"
11392                                 DaySky, DayHorizon,
11393                                 DawnSky, DawnHorizon,
11394                                 NightSky, NightHorizon,
11395                                 Indoor color.NRGBA
11396                         }))(obj)).NightHorizon
11397                         w.Write([]byte{x.A, x.R, x.G, x.B})
11398                 }
11399                 {
11400                         x := (*(*(struct {
11401                                 BgColor     color.NRGBA
11402                                 Type        string
11403                                 Clouds      bool
11404                                 SunFogTint  color.NRGBA
11405                                 MoonFogTint color.NRGBA
11406                                 FogTintType string
11407
11408                                 //mt:if %s.Type == "skybox"
11409                                 Textures []Texture
11410
11411                                 //mt:if %s.Type == "regular"
11412                                 DaySky, DayHorizon,
11413                                 DawnSky, DawnHorizon,
11414                                 NightSky, NightHorizon,
11415                                 Indoor color.NRGBA
11416                         }))(obj)).Indoor
11417                         w.Write([]byte{x.A, x.R, x.G, x.B})
11418                 }
11419         }
11420 }
11421
11422 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11423         {
11424                 p := &(*(*(struct {
11425                         BgColor     color.NRGBA
11426                         Type        string
11427                         Clouds      bool
11428                         SunFogTint  color.NRGBA
11429                         MoonFogTint color.NRGBA
11430                         FogTintType string
11431
11432                         //mt:if %s.Type == "skybox"
11433                         Textures []Texture
11434
11435                         //mt:if %s.Type == "regular"
11436                         DaySky, DayHorizon,
11437                         DawnSky, DawnHorizon,
11438                         NightSky, NightHorizon,
11439                         Indoor color.NRGBA
11440                 }))(obj)).BgColor
11441                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11442         }
11443         var local192 []uint8
11444         var local193 uint16
11445         {
11446                 p := &local193
11447                 *p = read16(r)
11448         }
11449         (local192) = make([]uint8, local193)
11450         {
11451                 _, err := io.ReadFull(r, (local192)[:])
11452                 chk(err)
11453         }
11454         ((*(*(struct {
11455                 BgColor     color.NRGBA
11456                 Type        string
11457                 Clouds      bool
11458                 SunFogTint  color.NRGBA
11459                 MoonFogTint color.NRGBA
11460                 FogTintType string
11461
11462                 //mt:if %s.Type == "skybox"
11463                 Textures []Texture
11464
11465                 //mt:if %s.Type == "regular"
11466                 DaySky, DayHorizon,
11467                 DawnSky, DawnHorizon,
11468                 NightSky, NightHorizon,
11469                 Indoor color.NRGBA
11470         }))(obj)).Type) = string(local192)
11471         {
11472                 p := &(*(*(struct {
11473                         BgColor     color.NRGBA
11474                         Type        string
11475                         Clouds      bool
11476                         SunFogTint  color.NRGBA
11477                         MoonFogTint color.NRGBA
11478                         FogTintType string
11479
11480                         //mt:if %s.Type == "skybox"
11481                         Textures []Texture
11482
11483                         //mt:if %s.Type == "regular"
11484                         DaySky, DayHorizon,
11485                         DawnSky, DawnHorizon,
11486                         NightSky, NightHorizon,
11487                         Indoor color.NRGBA
11488                 }))(obj)).Clouds
11489                 switch n := read8(r); n {
11490                 case 0:
11491                         *p = false
11492                 case 1:
11493                         *p = true
11494                 default:
11495                         chk(fmt.Errorf("invalid bool: %d", n))
11496                 }
11497         }
11498         {
11499                 p := &(*(*(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)).SunFogTint
11516                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11517         }
11518         {
11519                 p := &(*(*(struct {
11520                         BgColor     color.NRGBA
11521                         Type        string
11522                         Clouds      bool
11523                         SunFogTint  color.NRGBA
11524                         MoonFogTint color.NRGBA
11525                         FogTintType string
11526
11527                         //mt:if %s.Type == "skybox"
11528                         Textures []Texture
11529
11530                         //mt:if %s.Type == "regular"
11531                         DaySky, DayHorizon,
11532                         DawnSky, DawnHorizon,
11533                         NightSky, NightHorizon,
11534                         Indoor color.NRGBA
11535                 }))(obj)).MoonFogTint
11536                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11537         }
11538         var local194 []uint8
11539         var local195 uint16
11540         {
11541                 p := &local195
11542                 *p = read16(r)
11543         }
11544         (local194) = make([]uint8, local195)
11545         {
11546                 _, err := io.ReadFull(r, (local194)[:])
11547                 chk(err)
11548         }
11549         ((*(*(struct {
11550                 BgColor     color.NRGBA
11551                 Type        string
11552                 Clouds      bool
11553                 SunFogTint  color.NRGBA
11554                 MoonFogTint color.NRGBA
11555                 FogTintType string
11556
11557                 //mt:if %s.Type == "skybox"
11558                 Textures []Texture
11559
11560                 //mt:if %s.Type == "regular"
11561                 DaySky, DayHorizon,
11562                 DawnSky, DawnHorizon,
11563                 NightSky, NightHorizon,
11564                 Indoor color.NRGBA
11565         }))(obj)).FogTintType) = string(local194)
11566         if (*(*(struct {
11567                 BgColor     color.NRGBA
11568                 Type        string
11569                 Clouds      bool
11570                 SunFogTint  color.NRGBA
11571                 MoonFogTint color.NRGBA
11572                 FogTintType string
11573
11574                 //mt:if %s.Type == "skybox"
11575                 Textures []Texture
11576
11577                 //mt:if %s.Type == "regular"
11578                 DaySky, DayHorizon,
11579                 DawnSky, DawnHorizon,
11580                 NightSky, NightHorizon,
11581                 Indoor color.NRGBA
11582         }))(obj)).Type == "skybox" {
11583                 var local196 uint16
11584                 {
11585                         p := &local196
11586                         *p = read16(r)
11587                 }
11588                 ((*(*(struct {
11589                         BgColor     color.NRGBA
11590                         Type        string
11591                         Clouds      bool
11592                         SunFogTint  color.NRGBA
11593                         MoonFogTint color.NRGBA
11594                         FogTintType string
11595
11596                         //mt:if %s.Type == "skybox"
11597                         Textures []Texture
11598
11599                         //mt:if %s.Type == "regular"
11600                         DaySky, DayHorizon,
11601                         DawnSky, DawnHorizon,
11602                         NightSky, NightHorizon,
11603                         Indoor color.NRGBA
11604                 }))(obj)).Textures) = make([]Texture, local196)
11605                 for local197 := range (*(*(struct {
11606                         BgColor     color.NRGBA
11607                         Type        string
11608                         Clouds      bool
11609                         SunFogTint  color.NRGBA
11610                         MoonFogTint color.NRGBA
11611                         FogTintType string
11612
11613                         //mt:if %s.Type == "skybox"
11614                         Textures []Texture
11615
11616                         //mt:if %s.Type == "regular"
11617                         DaySky, DayHorizon,
11618                         DawnSky, DawnHorizon,
11619                         NightSky, NightHorizon,
11620                         Indoor color.NRGBA
11621                 }))(obj)).Textures {
11622                         if err := pcall(func() {
11623                                 (((*(*(struct {
11624                                         BgColor     color.NRGBA
11625                                         Type        string
11626                                         Clouds      bool
11627                                         SunFogTint  color.NRGBA
11628                                         MoonFogTint color.NRGBA
11629                                         FogTintType string
11630
11631                                         //mt:if %s.Type == "skybox"
11632                                         Textures []Texture
11633
11634                                         //mt:if %s.Type == "regular"
11635                                         DaySky, DayHorizon,
11636                                         DawnSky, DawnHorizon,
11637                                         NightSky, NightHorizon,
11638                                         Indoor color.NRGBA
11639                                 }))(obj)).Textures)[local197]).deserialize(r)
11640                         }); err != nil {
11641                                 if err == io.EOF {
11642                                         chk(io.EOF)
11643                                 }
11644                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
11645                         }
11646                 }
11647         }
11648         if (*(*(struct {
11649                 BgColor     color.NRGBA
11650                 Type        string
11651                 Clouds      bool
11652                 SunFogTint  color.NRGBA
11653                 MoonFogTint color.NRGBA
11654                 FogTintType string
11655
11656                 //mt:if %s.Type == "skybox"
11657                 Textures []Texture
11658
11659                 //mt:if %s.Type == "regular"
11660                 DaySky, DayHorizon,
11661                 DawnSky, DawnHorizon,
11662                 NightSky, NightHorizon,
11663                 Indoor color.NRGBA
11664         }))(obj)).Type == "regular" {
11665                 {
11666                         p := &(*(*(struct {
11667                                 BgColor     color.NRGBA
11668                                 Type        string
11669                                 Clouds      bool
11670                                 SunFogTint  color.NRGBA
11671                                 MoonFogTint color.NRGBA
11672                                 FogTintType string
11673
11674                                 //mt:if %s.Type == "skybox"
11675                                 Textures []Texture
11676
11677                                 //mt:if %s.Type == "regular"
11678                                 DaySky, DayHorizon,
11679                                 DawnSky, DawnHorizon,
11680                                 NightSky, NightHorizon,
11681                                 Indoor color.NRGBA
11682                         }))(obj)).DaySky
11683                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11684                 }
11685                 {
11686                         p := &(*(*(struct {
11687                                 BgColor     color.NRGBA
11688                                 Type        string
11689                                 Clouds      bool
11690                                 SunFogTint  color.NRGBA
11691                                 MoonFogTint color.NRGBA
11692                                 FogTintType string
11693
11694                                 //mt:if %s.Type == "skybox"
11695                                 Textures []Texture
11696
11697                                 //mt:if %s.Type == "regular"
11698                                 DaySky, DayHorizon,
11699                                 DawnSky, DawnHorizon,
11700                                 NightSky, NightHorizon,
11701                                 Indoor color.NRGBA
11702                         }))(obj)).DayHorizon
11703                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11704                 }
11705                 {
11706                         p := &(*(*(struct {
11707                                 BgColor     color.NRGBA
11708                                 Type        string
11709                                 Clouds      bool
11710                                 SunFogTint  color.NRGBA
11711                                 MoonFogTint color.NRGBA
11712                                 FogTintType string
11713
11714                                 //mt:if %s.Type == "skybox"
11715                                 Textures []Texture
11716
11717                                 //mt:if %s.Type == "regular"
11718                                 DaySky, DayHorizon,
11719                                 DawnSky, DawnHorizon,
11720                                 NightSky, NightHorizon,
11721                                 Indoor color.NRGBA
11722                         }))(obj)).DawnSky
11723                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11724                 }
11725                 {
11726                         p := &(*(*(struct {
11727                                 BgColor     color.NRGBA
11728                                 Type        string
11729                                 Clouds      bool
11730                                 SunFogTint  color.NRGBA
11731                                 MoonFogTint color.NRGBA
11732                                 FogTintType string
11733
11734                                 //mt:if %s.Type == "skybox"
11735                                 Textures []Texture
11736
11737                                 //mt:if %s.Type == "regular"
11738                                 DaySky, DayHorizon,
11739                                 DawnSky, DawnHorizon,
11740                                 NightSky, NightHorizon,
11741                                 Indoor color.NRGBA
11742                         }))(obj)).DawnHorizon
11743                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11744                 }
11745                 {
11746                         p := &(*(*(struct {
11747                                 BgColor     color.NRGBA
11748                                 Type        string
11749                                 Clouds      bool
11750                                 SunFogTint  color.NRGBA
11751                                 MoonFogTint color.NRGBA
11752                                 FogTintType string
11753
11754                                 //mt:if %s.Type == "skybox"
11755                                 Textures []Texture
11756
11757                                 //mt:if %s.Type == "regular"
11758                                 DaySky, DayHorizon,
11759                                 DawnSky, DawnHorizon,
11760                                 NightSky, NightHorizon,
11761                                 Indoor color.NRGBA
11762                         }))(obj)).NightSky
11763                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11764                 }
11765                 {
11766                         p := &(*(*(struct {
11767                                 BgColor     color.NRGBA
11768                                 Type        string
11769                                 Clouds      bool
11770                                 SunFogTint  color.NRGBA
11771                                 MoonFogTint color.NRGBA
11772                                 FogTintType string
11773
11774                                 //mt:if %s.Type == "skybox"
11775                                 Textures []Texture
11776
11777                                 //mt:if %s.Type == "regular"
11778                                 DaySky, DayHorizon,
11779                                 DawnSky, DawnHorizon,
11780                                 NightSky, NightHorizon,
11781                                 Indoor color.NRGBA
11782                         }))(obj)).NightHorizon
11783                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11784                 }
11785                 {
11786                         p := &(*(*(struct {
11787                                 BgColor     color.NRGBA
11788                                 Type        string
11789                                 Clouds      bool
11790                                 SunFogTint  color.NRGBA
11791                                 MoonFogTint color.NRGBA
11792                                 FogTintType string
11793
11794                                 //mt:if %s.Type == "skybox"
11795                                 Textures []Texture
11796
11797                                 //mt:if %s.Type == "regular"
11798                                 DaySky, DayHorizon,
11799                                 DawnSky, DawnHorizon,
11800                                 NightSky, NightHorizon,
11801                                 Indoor color.NRGBA
11802                         }))(obj)).Indoor
11803                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11804                 }
11805         }
11806 }
11807
11808 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
11809         {
11810                 x := (*(*(struct {
11811                         Override bool
11812                         Ratio    uint16
11813                 }))(obj)).Override
11814                 if x {
11815                         write8(w, 1)
11816                 } else {
11817                         write8(w, 0)
11818                 }
11819         }
11820         {
11821                 x := (*(*(struct {
11822                         Override bool
11823                         Ratio    uint16
11824                 }))(obj)).Ratio
11825                 write16(w, uint16(x))
11826         }
11827 }
11828
11829 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
11830         {
11831                 p := &(*(*(struct {
11832                         Override bool
11833                         Ratio    uint16
11834                 }))(obj)).Override
11835                 switch n := read8(r); n {
11836                 case 0:
11837                         *p = false
11838                 case 1:
11839                         *p = true
11840                 default:
11841                         chk(fmt.Errorf("invalid bool: %d", n))
11842                 }
11843         }
11844         {
11845                 p := &(*(*(struct {
11846                         Override bool
11847                         Ratio    uint16
11848                 }))(obj)).Ratio
11849                 *p = read16(r)
11850         }
11851 }
11852
11853 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
11854         for local198 := range (*(*(struct {
11855                 Idle, Walk, Dig, WalkDig [2]int32
11856                 Speed                    float32
11857         }))(obj)).Idle {
11858                 {
11859                         x := ((*(*(struct {
11860                                 Idle, Walk, Dig, WalkDig [2]int32
11861                                 Speed                    float32
11862                         }))(obj)).Idle)[local198]
11863                         write32(w, uint32(x))
11864                 }
11865         }
11866         for local199 := range (*(*(struct {
11867                 Idle, Walk, Dig, WalkDig [2]int32
11868                 Speed                    float32
11869         }))(obj)).Walk {
11870                 {
11871                         x := ((*(*(struct {
11872                                 Idle, Walk, Dig, WalkDig [2]int32
11873                                 Speed                    float32
11874                         }))(obj)).Walk)[local199]
11875                         write32(w, uint32(x))
11876                 }
11877         }
11878         for local200 := range (*(*(struct {
11879                 Idle, Walk, Dig, WalkDig [2]int32
11880                 Speed                    float32
11881         }))(obj)).Dig {
11882                 {
11883                         x := ((*(*(struct {
11884                                 Idle, Walk, Dig, WalkDig [2]int32
11885                                 Speed                    float32
11886                         }))(obj)).Dig)[local200]
11887                         write32(w, uint32(x))
11888                 }
11889         }
11890         for local201 := range (*(*(struct {
11891                 Idle, Walk, Dig, WalkDig [2]int32
11892                 Speed                    float32
11893         }))(obj)).WalkDig {
11894                 {
11895                         x := ((*(*(struct {
11896                                 Idle, Walk, Dig, WalkDig [2]int32
11897                                 Speed                    float32
11898                         }))(obj)).WalkDig)[local201]
11899                         write32(w, uint32(x))
11900                 }
11901         }
11902         {
11903                 x := (*(*(struct {
11904                         Idle, Walk, Dig, WalkDig [2]int32
11905                         Speed                    float32
11906                 }))(obj)).Speed
11907                 write32(w, math.Float32bits(x))
11908         }
11909 }
11910
11911 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
11912         for local202 := range (*(*(struct {
11913                 Idle, Walk, Dig, WalkDig [2]int32
11914                 Speed                    float32
11915         }))(obj)).Idle {
11916                 {
11917                         p := &((*(*(struct {
11918                                 Idle, Walk, Dig, WalkDig [2]int32
11919                                 Speed                    float32
11920                         }))(obj)).Idle)[local202]
11921                         *p = int32(read32(r))
11922                 }
11923         }
11924         for local203 := range (*(*(struct {
11925                 Idle, Walk, Dig, WalkDig [2]int32
11926                 Speed                    float32
11927         }))(obj)).Walk {
11928                 {
11929                         p := &((*(*(struct {
11930                                 Idle, Walk, Dig, WalkDig [2]int32
11931                                 Speed                    float32
11932                         }))(obj)).Walk)[local203]
11933                         *p = int32(read32(r))
11934                 }
11935         }
11936         for local204 := range (*(*(struct {
11937                 Idle, Walk, Dig, WalkDig [2]int32
11938                 Speed                    float32
11939         }))(obj)).Dig {
11940                 {
11941                         p := &((*(*(struct {
11942                                 Idle, Walk, Dig, WalkDig [2]int32
11943                                 Speed                    float32
11944                         }))(obj)).Dig)[local204]
11945                         *p = int32(read32(r))
11946                 }
11947         }
11948         for local205 := range (*(*(struct {
11949                 Idle, Walk, Dig, WalkDig [2]int32
11950                 Speed                    float32
11951         }))(obj)).WalkDig {
11952                 {
11953                         p := &((*(*(struct {
11954                                 Idle, Walk, Dig, WalkDig [2]int32
11955                                 Speed                    float32
11956                         }))(obj)).WalkDig)[local205]
11957                         *p = int32(read32(r))
11958                 }
11959         }
11960         {
11961                 p := &(*(*(struct {
11962                         Idle, Walk, Dig, WalkDig [2]int32
11963                         Speed                    float32
11964                 }))(obj)).Speed
11965                 *p = math.Float32frombits(read32(r))
11966         }
11967 }
11968
11969 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
11970         if err := pcall(func() {
11971                 ((*(*(struct {
11972                         First, Third Vec
11973                 }))(obj)).First).serialize(w)
11974         }); err != nil {
11975                 if err == io.EOF {
11976                         chk(io.EOF)
11977                 }
11978                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
11979         }
11980         if err := pcall(func() {
11981                 ((*(*(struct {
11982                         First, Third Vec
11983                 }))(obj)).Third).serialize(w)
11984         }); err != nil {
11985                 if err == io.EOF {
11986                         chk(io.EOF)
11987                 }
11988                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
11989         }
11990 }
11991
11992 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
11993         if err := pcall(func() {
11994                 ((*(*(struct {
11995                         First, Third Vec
11996                 }))(obj)).First).deserialize(r)
11997         }); err != nil {
11998                 if err == io.EOF {
11999                         chk(io.EOF)
12000                 }
12001                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
12002         }
12003         if err := pcall(func() {
12004                 ((*(*(struct {
12005                         First, Third Vec
12006                 }))(obj)).Third).deserialize(r)
12007         }); err != nil {
12008                 if err == io.EOF {
12009                         chk(io.EOF)
12010                 }
12011                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
12012         }
12013 }
12014
12015 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12016         if err := pcall(func() {
12017                 ((*(*(struct {
12018                         ID ParticleSpawnerID
12019                 }))(obj)).ID).serialize(w)
12020         }); err != nil {
12021                 if err == io.EOF {
12022                         chk(io.EOF)
12023                 }
12024                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
12025         }
12026 }
12027
12028 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12029         if err := pcall(func() {
12030                 ((*(*(struct {
12031                         ID ParticleSpawnerID
12032                 }))(obj)).ID).deserialize(r)
12033         }); err != nil {
12034                 if err == io.EOF {
12035                         chk(io.EOF)
12036                 }
12037                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
12038         }
12039 }
12040
12041 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12042         {
12043                 x := (*(*(struct {
12044                         Density      float32
12045                         DiffuseColor color.NRGBA
12046                         AmbientColor color.NRGBA
12047                         Height       float32
12048                         Thickness    float32
12049                         Speed        [2]float32
12050                 }))(obj)).Density
12051                 write32(w, math.Float32bits(x))
12052         }
12053         {
12054                 x := (*(*(struct {
12055                         Density      float32
12056                         DiffuseColor color.NRGBA
12057                         AmbientColor color.NRGBA
12058                         Height       float32
12059                         Thickness    float32
12060                         Speed        [2]float32
12061                 }))(obj)).DiffuseColor
12062                 w.Write([]byte{x.A, x.R, x.G, x.B})
12063         }
12064         {
12065                 x := (*(*(struct {
12066                         Density      float32
12067                         DiffuseColor color.NRGBA
12068                         AmbientColor color.NRGBA
12069                         Height       float32
12070                         Thickness    float32
12071                         Speed        [2]float32
12072                 }))(obj)).AmbientColor
12073                 w.Write([]byte{x.A, x.R, x.G, x.B})
12074         }
12075         {
12076                 x := (*(*(struct {
12077                         Density      float32
12078                         DiffuseColor color.NRGBA
12079                         AmbientColor color.NRGBA
12080                         Height       float32
12081                         Thickness    float32
12082                         Speed        [2]float32
12083                 }))(obj)).Height
12084                 write32(w, math.Float32bits(x))
12085         }
12086         {
12087                 x := (*(*(struct {
12088                         Density      float32
12089                         DiffuseColor color.NRGBA
12090                         AmbientColor color.NRGBA
12091                         Height       float32
12092                         Thickness    float32
12093                         Speed        [2]float32
12094                 }))(obj)).Thickness
12095                 write32(w, math.Float32bits(x))
12096         }
12097         for local206 := range (*(*(struct {
12098                 Density      float32
12099                 DiffuseColor color.NRGBA
12100                 AmbientColor color.NRGBA
12101                 Height       float32
12102                 Thickness    float32
12103                 Speed        [2]float32
12104         }))(obj)).Speed {
12105                 {
12106                         x := ((*(*(struct {
12107                                 Density      float32
12108                                 DiffuseColor color.NRGBA
12109                                 AmbientColor color.NRGBA
12110                                 Height       float32
12111                                 Thickness    float32
12112                                 Speed        [2]float32
12113                         }))(obj)).Speed)[local206]
12114                         write32(w, math.Float32bits(x))
12115                 }
12116         }
12117 }
12118
12119 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12120         {
12121                 p := &(*(*(struct {
12122                         Density      float32
12123                         DiffuseColor color.NRGBA
12124                         AmbientColor color.NRGBA
12125                         Height       float32
12126                         Thickness    float32
12127                         Speed        [2]float32
12128                 }))(obj)).Density
12129                 *p = math.Float32frombits(read32(r))
12130         }
12131         {
12132                 p := &(*(*(struct {
12133                         Density      float32
12134                         DiffuseColor color.NRGBA
12135                         AmbientColor color.NRGBA
12136                         Height       float32
12137                         Thickness    float32
12138                         Speed        [2]float32
12139                 }))(obj)).DiffuseColor
12140                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12141         }
12142         {
12143                 p := &(*(*(struct {
12144                         Density      float32
12145                         DiffuseColor color.NRGBA
12146                         AmbientColor color.NRGBA
12147                         Height       float32
12148                         Thickness    float32
12149                         Speed        [2]float32
12150                 }))(obj)).AmbientColor
12151                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12152         }
12153         {
12154                 p := &(*(*(struct {
12155                         Density      float32
12156                         DiffuseColor color.NRGBA
12157                         AmbientColor color.NRGBA
12158                         Height       float32
12159                         Thickness    float32
12160                         Speed        [2]float32
12161                 }))(obj)).Height
12162                 *p = math.Float32frombits(read32(r))
12163         }
12164         {
12165                 p := &(*(*(struct {
12166                         Density      float32
12167                         DiffuseColor color.NRGBA
12168                         AmbientColor color.NRGBA
12169                         Height       float32
12170                         Thickness    float32
12171                         Speed        [2]float32
12172                 }))(obj)).Thickness
12173                 *p = math.Float32frombits(read32(r))
12174         }
12175         for local207 := range (*(*(struct {
12176                 Density      float32
12177                 DiffuseColor color.NRGBA
12178                 AmbientColor color.NRGBA
12179                 Height       float32
12180                 Thickness    float32
12181                 Speed        [2]float32
12182         }))(obj)).Speed {
12183                 {
12184                         p := &((*(*(struct {
12185                                 Density      float32
12186                                 DiffuseColor color.NRGBA
12187                                 AmbientColor color.NRGBA
12188                                 Height       float32
12189                                 Thickness    float32
12190                                 Speed        [2]float32
12191                         }))(obj)).Speed)[local207]
12192                         *p = math.Float32frombits(read32(r))
12193                 }
12194         }
12195 }
12196
12197 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12198         if err := pcall(func() {
12199                 ((*(*(struct {
12200                         ID   SoundID
12201                         Step float32
12202                         Gain float32
12203                 }))(obj)).ID).serialize(w)
12204         }); err != nil {
12205                 if err == io.EOF {
12206                         chk(io.EOF)
12207                 }
12208                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
12209         }
12210         {
12211                 x := (*(*(struct {
12212                         ID   SoundID
12213                         Step float32
12214                         Gain float32
12215                 }))(obj)).Step
12216                 write32(w, math.Float32bits(x))
12217         }
12218         {
12219                 x := (*(*(struct {
12220                         ID   SoundID
12221                         Step float32
12222                         Gain float32
12223                 }))(obj)).Gain
12224                 write32(w, math.Float32bits(x))
12225         }
12226 }
12227
12228 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12229         if err := pcall(func() {
12230                 ((*(*(struct {
12231                         ID   SoundID
12232                         Step float32
12233                         Gain float32
12234                 }))(obj)).ID).deserialize(r)
12235         }); err != nil {
12236                 if err == io.EOF {
12237                         chk(io.EOF)
12238                 }
12239                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
12240         }
12241         {
12242                 p := &(*(*(struct {
12243                         ID   SoundID
12244                         Step float32
12245                         Gain float32
12246                 }))(obj)).Step
12247                 *p = math.Float32frombits(read32(r))
12248         }
12249         {
12250                 p := &(*(*(struct {
12251                         ID   SoundID
12252                         Step float32
12253                         Gain float32
12254                 }))(obj)).Gain
12255                 *p = math.Float32frombits(read32(r))
12256         }
12257 }
12258
12259 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12260         if err := pcall(func() {
12261                 ((*(*(struct {
12262                         Type    PlayerListUpdateType
12263                         Players []string
12264                 }))(obj)).Type).serialize(w)
12265         }); err != nil {
12266                 if err == io.EOF {
12267                         chk(io.EOF)
12268                 }
12269                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerListUpdateType", err))
12270         }
12271         if len(((*(*(struct {
12272                 Type    PlayerListUpdateType
12273                 Players []string
12274         }))(obj)).Players)) > math.MaxUint16 {
12275                 chk(ErrTooLong)
12276         }
12277         {
12278                 x := uint16(len(((*(*(struct {
12279                         Type    PlayerListUpdateType
12280                         Players []string
12281                 }))(obj)).Players)))
12282                 write16(w, uint16(x))
12283         }
12284         for local208 := range (*(*(struct {
12285                 Type    PlayerListUpdateType
12286                 Players []string
12287         }))(obj)).Players {
12288                 if len(([]byte(((*(*(struct {
12289                         Type    PlayerListUpdateType
12290                         Players []string
12291                 }))(obj)).Players)[local208]))) > math.MaxUint16 {
12292                         chk(ErrTooLong)
12293                 }
12294                 {
12295                         x := uint16(len(([]byte(((*(*(struct {
12296                                 Type    PlayerListUpdateType
12297                                 Players []string
12298                         }))(obj)).Players)[local208]))))
12299                         write16(w, uint16(x))
12300                 }
12301                 {
12302                         _, err := w.Write(([]byte(((*(*(struct {
12303                                 Type    PlayerListUpdateType
12304                                 Players []string
12305                         }))(obj)).Players)[local208]))[:])
12306                         chk(err)
12307                 }
12308         }
12309 }
12310
12311 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12312         if err := pcall(func() {
12313                 ((*(*(struct {
12314                         Type    PlayerListUpdateType
12315                         Players []string
12316                 }))(obj)).Type).deserialize(r)
12317         }); err != nil {
12318                 if err == io.EOF {
12319                         chk(io.EOF)
12320                 }
12321                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerListUpdateType", err))
12322         }
12323         var local209 uint16
12324         {
12325                 p := &local209
12326                 *p = read16(r)
12327         }
12328         ((*(*(struct {
12329                 Type    PlayerListUpdateType
12330                 Players []string
12331         }))(obj)).Players) = make([]string, local209)
12332         for local210 := range (*(*(struct {
12333                 Type    PlayerListUpdateType
12334                 Players []string
12335         }))(obj)).Players {
12336                 var local211 []uint8
12337                 var local212 uint16
12338                 {
12339                         p := &local212
12340                         *p = read16(r)
12341                 }
12342                 (local211) = make([]uint8, local212)
12343                 {
12344                         _, err := io.ReadFull(r, (local211)[:])
12345                         chk(err)
12346                 }
12347                 (((*(*(struct {
12348                         Type    PlayerListUpdateType
12349                         Players []string
12350                 }))(obj)).Players)[local210]) = string(local211)
12351         }
12352 }
12353
12354 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12355         if len(([]byte((*(*(struct {
12356                 Channel string
12357                 Sender  string
12358                 Msg     string
12359         }))(obj)).Channel))) > math.MaxUint16 {
12360                 chk(ErrTooLong)
12361         }
12362         {
12363                 x := uint16(len(([]byte((*(*(struct {
12364                         Channel string
12365                         Sender  string
12366                         Msg     string
12367                 }))(obj)).Channel))))
12368                 write16(w, uint16(x))
12369         }
12370         {
12371                 _, err := w.Write(([]byte((*(*(struct {
12372                         Channel string
12373                         Sender  string
12374                         Msg     string
12375                 }))(obj)).Channel))[:])
12376                 chk(err)
12377         }
12378         if len(([]byte((*(*(struct {
12379                 Channel string
12380                 Sender  string
12381                 Msg     string
12382         }))(obj)).Sender))) > math.MaxUint16 {
12383                 chk(ErrTooLong)
12384         }
12385         {
12386                 x := uint16(len(([]byte((*(*(struct {
12387                         Channel string
12388                         Sender  string
12389                         Msg     string
12390                 }))(obj)).Sender))))
12391                 write16(w, uint16(x))
12392         }
12393         {
12394                 _, err := w.Write(([]byte((*(*(struct {
12395                         Channel string
12396                         Sender  string
12397                         Msg     string
12398                 }))(obj)).Sender))[:])
12399                 chk(err)
12400         }
12401         if len(([]byte((*(*(struct {
12402                 Channel string
12403                 Sender  string
12404                 Msg     string
12405         }))(obj)).Msg))) > math.MaxUint16 {
12406                 chk(ErrTooLong)
12407         }
12408         {
12409                 x := uint16(len(([]byte((*(*(struct {
12410                         Channel string
12411                         Sender  string
12412                         Msg     string
12413                 }))(obj)).Msg))))
12414                 write16(w, uint16(x))
12415         }
12416         {
12417                 _, err := w.Write(([]byte((*(*(struct {
12418                         Channel string
12419                         Sender  string
12420                         Msg     string
12421                 }))(obj)).Msg))[:])
12422                 chk(err)
12423         }
12424 }
12425
12426 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12427         var local213 []uint8
12428         var local214 uint16
12429         {
12430                 p := &local214
12431                 *p = read16(r)
12432         }
12433         (local213) = make([]uint8, local214)
12434         {
12435                 _, err := io.ReadFull(r, (local213)[:])
12436                 chk(err)
12437         }
12438         ((*(*(struct {
12439                 Channel string
12440                 Sender  string
12441                 Msg     string
12442         }))(obj)).Channel) = string(local213)
12443         var local215 []uint8
12444         var local216 uint16
12445         {
12446                 p := &local216
12447                 *p = read16(r)
12448         }
12449         (local215) = make([]uint8, local216)
12450         {
12451                 _, err := io.ReadFull(r, (local215)[:])
12452                 chk(err)
12453         }
12454         ((*(*(struct {
12455                 Channel string
12456                 Sender  string
12457                 Msg     string
12458         }))(obj)).Sender) = string(local215)
12459         var local217 []uint8
12460         var local218 uint16
12461         {
12462                 p := &local218
12463                 *p = read16(r)
12464         }
12465         (local217) = make([]uint8, local218)
12466         {
12467                 _, err := io.ReadFull(r, (local217)[:])
12468                 chk(err)
12469         }
12470         ((*(*(struct {
12471                 Channel string
12472                 Sender  string
12473                 Msg     string
12474         }))(obj)).Msg) = string(local217)
12475 }
12476
12477 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12478         if err := pcall(func() {
12479                 ((*(*(struct {
12480                         Signal  ModChanSig
12481                         Channel string
12482                 }))(obj)).Signal).serialize(w)
12483         }); err != nil {
12484                 if err == io.EOF {
12485                         chk(io.EOF)
12486                 }
12487                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ModChanSig", err))
12488         }
12489         if len(([]byte((*(*(struct {
12490                 Signal  ModChanSig
12491                 Channel string
12492         }))(obj)).Channel))) > math.MaxUint16 {
12493                 chk(ErrTooLong)
12494         }
12495         {
12496                 x := uint16(len(([]byte((*(*(struct {
12497                         Signal  ModChanSig
12498                         Channel string
12499                 }))(obj)).Channel))))
12500                 write16(w, uint16(x))
12501         }
12502         {
12503                 _, err := w.Write(([]byte((*(*(struct {
12504                         Signal  ModChanSig
12505                         Channel string
12506                 }))(obj)).Channel))[:])
12507                 chk(err)
12508         }
12509 }
12510
12511 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12512         if err := pcall(func() {
12513                 ((*(*(struct {
12514                         Signal  ModChanSig
12515                         Channel string
12516                 }))(obj)).Signal).deserialize(r)
12517         }); err != nil {
12518                 if err == io.EOF {
12519                         chk(io.EOF)
12520                 }
12521                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ModChanSig", err))
12522         }
12523         var local219 []uint8
12524         var local220 uint16
12525         {
12526                 p := &local220
12527                 *p = read16(r)
12528         }
12529         (local219) = make([]uint8, local220)
12530         {
12531                 _, err := io.ReadFull(r, (local219)[:])
12532                 chk(err)
12533         }
12534         ((*(*(struct {
12535                 Signal  ModChanSig
12536                 Channel string
12537         }))(obj)).Channel) = string(local219)
12538 }
12539
12540 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12541         {
12542                 ow := w
12543                 w := new(bytes.Buffer)
12544                 {
12545                         x := (*(*(struct {
12546                                 //mt:lenhdr 32
12547                                 Changed map[[3]int16]*NodeMeta
12548                         }))(obj)).Changed
12549                         {
12550                                 w := zlib.NewWriter(w)
12551                                 if x == nil {
12552                                         write8(w, 0)
12553                                 } else {
12554                                         write8(w, 2)
12555                                         if len(x) > math.MaxUint16 {
12556                                                 chk(ErrTooLong)
12557                                         }
12558                                         write16(w, uint16(len(x)))
12559                                         keys := make([][3]int16, 0, len(x))
12560                                         for key := range x {
12561                                                 keys = append(keys, key)
12562                                         }
12563                                         sort.Slice(keys, func(i, j int) bool {
12564                                                 p, q := keys[i], keys[j]
12565                                                 for i := range p {
12566                                                         switch {
12567                                                         case p[i] < q[i]:
12568                                                                 return true
12569                                                         case p[i] > q[i]:
12570                                                                 return false
12571                                                         }
12572                                                 }
12573                                                 return false
12574                                         })
12575                                         for _, key := range keys {
12576                                                 for _, n := range key {
12577                                                         write16(w, uint16(n))
12578                                                 }
12579                                                 chk(serialize(w, x[key]))
12580                                         }
12581                                 }
12582                                 chk(w.Close())
12583                         }
12584                 }
12585                 {
12586                         buf := w
12587                         w := ow
12588                         if len((buf.Bytes())) > math.MaxUint32 {
12589                                 chk(ErrTooLong)
12590                         }
12591                         {
12592                                 x := uint32(len((buf.Bytes())))
12593                                 write32(w, uint32(x))
12594                         }
12595                         {
12596                                 _, err := w.Write((buf.Bytes())[:])
12597                                 chk(err)
12598                         }
12599                 }
12600         }
12601 }
12602
12603 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
12604         {
12605                 var n uint32
12606                 {
12607                         p := &n
12608                         *p = read32(r)
12609                 }
12610                 r := &io.LimitedReader{R: r, N: int64(n)}
12611                 {
12612                         p := &(*(*(struct {
12613                                 //mt:lenhdr 32
12614                                 Changed map[[3]int16]*NodeMeta
12615                         }))(obj)).Changed
12616                         {
12617                                 r, err := zlib.NewReader(byteReader{r})
12618                                 chk(err)
12619                                 switch ver := read8(r); ver {
12620                                 case 0:
12621                                         *p = nil
12622                                 case 2:
12623                                         n := read16(r)
12624                                         *p = make(map[[3]int16]*NodeMeta, n)
12625                                         for ; n > 0; n-- {
12626                                                 var pos [3]int16
12627                                                 for i := range pos {
12628                                                         pos[i] = int16(read16(r))
12629                                                 }
12630                                                 nm := new(NodeMeta)
12631                                                 chk(deserialize(r, nm))
12632                                                 (*p)[pos] = nm
12633                                         }
12634                                 default:
12635                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
12636                                 }
12637                                 chk(r.Close())
12638                         }
12639                 }
12640                 if r.N > 0 {
12641                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
12642                 }
12643         }
12644 }
12645
12646 func (obj *ToCltSunParams) serialize(w io.Writer) {
12647         {
12648                 x := (*(*(struct {
12649                         Visible bool
12650                         Texture
12651                         ToneMap Texture
12652                         Rise    Texture
12653                         Rising  bool
12654                         Size    float32
12655                 }))(obj)).Visible
12656                 if x {
12657                         write8(w, 1)
12658                 } else {
12659                         write8(w, 0)
12660                 }
12661         }
12662         if err := pcall(func() {
12663                 ((*(*(struct {
12664                         Visible bool
12665                         Texture
12666                         ToneMap Texture
12667                         Rise    Texture
12668                         Rising  bool
12669                         Size    float32
12670                 }))(obj)).Texture).serialize(w)
12671         }); err != nil {
12672                 if err == io.EOF {
12673                         chk(io.EOF)
12674                 }
12675                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12676         }
12677         if err := pcall(func() {
12678                 ((*(*(struct {
12679                         Visible bool
12680                         Texture
12681                         ToneMap Texture
12682                         Rise    Texture
12683                         Rising  bool
12684                         Size    float32
12685                 }))(obj)).ToneMap).serialize(w)
12686         }); err != nil {
12687                 if err == io.EOF {
12688                         chk(io.EOF)
12689                 }
12690                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12691         }
12692         if err := pcall(func() {
12693                 ((*(*(struct {
12694                         Visible bool
12695                         Texture
12696                         ToneMap Texture
12697                         Rise    Texture
12698                         Rising  bool
12699                         Size    float32
12700                 }))(obj)).Rise).serialize(w)
12701         }); err != nil {
12702                 if err == io.EOF {
12703                         chk(io.EOF)
12704                 }
12705                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12706         }
12707         {
12708                 x := (*(*(struct {
12709                         Visible bool
12710                         Texture
12711                         ToneMap Texture
12712                         Rise    Texture
12713                         Rising  bool
12714                         Size    float32
12715                 }))(obj)).Rising
12716                 if x {
12717                         write8(w, 1)
12718                 } else {
12719                         write8(w, 0)
12720                 }
12721         }
12722         {
12723                 x := (*(*(struct {
12724                         Visible bool
12725                         Texture
12726                         ToneMap Texture
12727                         Rise    Texture
12728                         Rising  bool
12729                         Size    float32
12730                 }))(obj)).Size
12731                 write32(w, math.Float32bits(x))
12732         }
12733 }
12734
12735 func (obj *ToCltSunParams) deserialize(r io.Reader) {
12736         {
12737                 p := &(*(*(struct {
12738                         Visible bool
12739                         Texture
12740                         ToneMap Texture
12741                         Rise    Texture
12742                         Rising  bool
12743                         Size    float32
12744                 }))(obj)).Visible
12745                 switch n := read8(r); n {
12746                 case 0:
12747                         *p = false
12748                 case 1:
12749                         *p = true
12750                 default:
12751                         chk(fmt.Errorf("invalid bool: %d", n))
12752                 }
12753         }
12754         if err := pcall(func() {
12755                 ((*(*(struct {
12756                         Visible bool
12757                         Texture
12758                         ToneMap Texture
12759                         Rise    Texture
12760                         Rising  bool
12761                         Size    float32
12762                 }))(obj)).Texture).deserialize(r)
12763         }); err != nil {
12764                 if err == io.EOF {
12765                         chk(io.EOF)
12766                 }
12767                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12768         }
12769         if err := pcall(func() {
12770                 ((*(*(struct {
12771                         Visible bool
12772                         Texture
12773                         ToneMap Texture
12774                         Rise    Texture
12775                         Rising  bool
12776                         Size    float32
12777                 }))(obj)).ToneMap).deserialize(r)
12778         }); err != nil {
12779                 if err == io.EOF {
12780                         chk(io.EOF)
12781                 }
12782                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12783         }
12784         if err := pcall(func() {
12785                 ((*(*(struct {
12786                         Visible bool
12787                         Texture
12788                         ToneMap Texture
12789                         Rise    Texture
12790                         Rising  bool
12791                         Size    float32
12792                 }))(obj)).Rise).deserialize(r)
12793         }); err != nil {
12794                 if err == io.EOF {
12795                         chk(io.EOF)
12796                 }
12797                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12798         }
12799         {
12800                 p := &(*(*(struct {
12801                         Visible bool
12802                         Texture
12803                         ToneMap Texture
12804                         Rise    Texture
12805                         Rising  bool
12806                         Size    float32
12807                 }))(obj)).Rising
12808                 switch n := read8(r); n {
12809                 case 0:
12810                         *p = false
12811                 case 1:
12812                         *p = true
12813                 default:
12814                         chk(fmt.Errorf("invalid bool: %d", n))
12815                 }
12816         }
12817         {
12818                 p := &(*(*(struct {
12819                         Visible bool
12820                         Texture
12821                         ToneMap Texture
12822                         Rise    Texture
12823                         Rising  bool
12824                         Size    float32
12825                 }))(obj)).Size
12826                 *p = math.Float32frombits(read32(r))
12827         }
12828 }
12829
12830 func (obj *ToCltMoonParams) serialize(w io.Writer) {
12831         {
12832                 x := (*(*(struct {
12833                         Visible bool
12834                         Texture
12835                         ToneMap Texture
12836                         Size    float32
12837                 }))(obj)).Visible
12838                 if x {
12839                         write8(w, 1)
12840                 } else {
12841                         write8(w, 0)
12842                 }
12843         }
12844         if err := pcall(func() {
12845                 ((*(*(struct {
12846                         Visible bool
12847                         Texture
12848                         ToneMap Texture
12849                         Size    float32
12850                 }))(obj)).Texture).serialize(w)
12851         }); err != nil {
12852                 if err == io.EOF {
12853                         chk(io.EOF)
12854                 }
12855                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12856         }
12857         if err := pcall(func() {
12858                 ((*(*(struct {
12859                         Visible bool
12860                         Texture
12861                         ToneMap Texture
12862                         Size    float32
12863                 }))(obj)).ToneMap).serialize(w)
12864         }); err != nil {
12865                 if err == io.EOF {
12866                         chk(io.EOF)
12867                 }
12868                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12869         }
12870         {
12871                 x := (*(*(struct {
12872                         Visible bool
12873                         Texture
12874                         ToneMap Texture
12875                         Size    float32
12876                 }))(obj)).Size
12877                 write32(w, math.Float32bits(x))
12878         }
12879 }
12880
12881 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
12882         {
12883                 p := &(*(*(struct {
12884                         Visible bool
12885                         Texture
12886                         ToneMap Texture
12887                         Size    float32
12888                 }))(obj)).Visible
12889                 switch n := read8(r); n {
12890                 case 0:
12891                         *p = false
12892                 case 1:
12893                         *p = true
12894                 default:
12895                         chk(fmt.Errorf("invalid bool: %d", n))
12896                 }
12897         }
12898         if err := pcall(func() {
12899                 ((*(*(struct {
12900                         Visible bool
12901                         Texture
12902                         ToneMap Texture
12903                         Size    float32
12904                 }))(obj)).Texture).deserialize(r)
12905         }); err != nil {
12906                 if err == io.EOF {
12907                         chk(io.EOF)
12908                 }
12909                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12910         }
12911         if err := pcall(func() {
12912                 ((*(*(struct {
12913                         Visible bool
12914                         Texture
12915                         ToneMap Texture
12916                         Size    float32
12917                 }))(obj)).ToneMap).deserialize(r)
12918         }); err != nil {
12919                 if err == io.EOF {
12920                         chk(io.EOF)
12921                 }
12922                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12923         }
12924         {
12925                 p := &(*(*(struct {
12926                         Visible bool
12927                         Texture
12928                         ToneMap Texture
12929                         Size    float32
12930                 }))(obj)).Size
12931                 *p = math.Float32frombits(read32(r))
12932         }
12933 }
12934
12935 func (obj *ToCltStarParams) serialize(w io.Writer) {
12936         {
12937                 x := (*(*(struct {
12938                         Visible bool
12939                         Count   uint32
12940                         Color   color.NRGBA
12941                         Size    float32
12942                 }))(obj)).Visible
12943                 if x {
12944                         write8(w, 1)
12945                 } else {
12946                         write8(w, 0)
12947                 }
12948         }
12949         {
12950                 x := (*(*(struct {
12951                         Visible bool
12952                         Count   uint32
12953                         Color   color.NRGBA
12954                         Size    float32
12955                 }))(obj)).Count
12956                 write32(w, uint32(x))
12957         }
12958         {
12959                 x := (*(*(struct {
12960                         Visible bool
12961                         Count   uint32
12962                         Color   color.NRGBA
12963                         Size    float32
12964                 }))(obj)).Color
12965                 w.Write([]byte{x.A, x.R, x.G, x.B})
12966         }
12967         {
12968                 x := (*(*(struct {
12969                         Visible bool
12970                         Count   uint32
12971                         Color   color.NRGBA
12972                         Size    float32
12973                 }))(obj)).Size
12974                 write32(w, math.Float32bits(x))
12975         }
12976 }
12977
12978 func (obj *ToCltStarParams) deserialize(r io.Reader) {
12979         {
12980                 p := &(*(*(struct {
12981                         Visible bool
12982                         Count   uint32
12983                         Color   color.NRGBA
12984                         Size    float32
12985                 }))(obj)).Visible
12986                 switch n := read8(r); n {
12987                 case 0:
12988                         *p = false
12989                 case 1:
12990                         *p = true
12991                 default:
12992                         chk(fmt.Errorf("invalid bool: %d", n))
12993                 }
12994         }
12995         {
12996                 p := &(*(*(struct {
12997                         Visible bool
12998                         Count   uint32
12999                         Color   color.NRGBA
13000                         Size    float32
13001                 }))(obj)).Count
13002                 *p = read32(r)
13003         }
13004         {
13005                 p := &(*(*(struct {
13006                         Visible bool
13007                         Count   uint32
13008                         Color   color.NRGBA
13009                         Size    float32
13010                 }))(obj)).Color
13011                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13012         }
13013         {
13014                 p := &(*(*(struct {
13015                         Visible bool
13016                         Count   uint32
13017                         Color   color.NRGBA
13018                         Size    float32
13019                 }))(obj)).Size
13020                 *p = math.Float32frombits(read32(r))
13021         }
13022 }
13023
13024 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13025         if len(((*(*(struct {
13026                 Salt, B []byte
13027         }))(obj)).Salt)) > math.MaxUint16 {
13028                 chk(ErrTooLong)
13029         }
13030         {
13031                 x := uint16(len(((*(*(struct {
13032                         Salt, B []byte
13033                 }))(obj)).Salt)))
13034                 write16(w, uint16(x))
13035         }
13036         {
13037                 _, err := w.Write(((*(*(struct {
13038                         Salt, B []byte
13039                 }))(obj)).Salt)[:])
13040                 chk(err)
13041         }
13042         if len(((*(*(struct {
13043                 Salt, B []byte
13044         }))(obj)).B)) > math.MaxUint16 {
13045                 chk(ErrTooLong)
13046         }
13047         {
13048                 x := uint16(len(((*(*(struct {
13049                         Salt, B []byte
13050                 }))(obj)).B)))
13051                 write16(w, uint16(x))
13052         }
13053         {
13054                 _, err := w.Write(((*(*(struct {
13055                         Salt, B []byte
13056                 }))(obj)).B)[:])
13057                 chk(err)
13058         }
13059 }
13060
13061 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13062         var local221 uint16
13063         {
13064                 p := &local221
13065                 *p = read16(r)
13066         }
13067         ((*(*(struct {
13068                 Salt, B []byte
13069         }))(obj)).Salt) = make([]byte, local221)
13070         {
13071                 _, err := io.ReadFull(r, ((*(*(struct {
13072                         Salt, B []byte
13073                 }))(obj)).Salt)[:])
13074                 chk(err)
13075         }
13076         var local222 uint16
13077         {
13078                 p := &local222
13079                 *p = read16(r)
13080         }
13081         ((*(*(struct {
13082                 Salt, B []byte
13083         }))(obj)).B) = make([]byte, local222)
13084         {
13085                 _, err := io.ReadFull(r, ((*(*(struct {
13086                         Salt, B []byte
13087                 }))(obj)).B)[:])
13088                 chk(err)
13089         }
13090 }
13091
13092 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13093         if len(([]byte((*(*(struct {
13094                 Prepend string
13095         }))(obj)).Prepend))) > math.MaxUint16 {
13096                 chk(ErrTooLong)
13097         }
13098         {
13099                 x := uint16(len(([]byte((*(*(struct {
13100                         Prepend string
13101                 }))(obj)).Prepend))))
13102                 write16(w, uint16(x))
13103         }
13104         {
13105                 _, err := w.Write(([]byte((*(*(struct {
13106                         Prepend string
13107                 }))(obj)).Prepend))[:])
13108                 chk(err)
13109         }
13110 }
13111
13112 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13113         var local223 []uint8
13114         var local224 uint16
13115         {
13116                 p := &local224
13117                 *p = read16(r)
13118         }
13119         (local223) = make([]uint8, local224)
13120         {
13121                 _, err := io.ReadFull(r, (local223)[:])
13122                 chk(err)
13123         }
13124         ((*(*(struct {
13125                 Prepend string
13126         }))(obj)).Prepend) = string(local223)
13127 }
13128
13129 func (obj *AOCmdProps) serialize(w io.Writer) {
13130         if err := pcall(func() {
13131                 ((*(*(struct {
13132                         Props AOProps
13133                 }))(obj)).Props).serialize(w)
13134         }); err != nil {
13135                 if err == io.EOF {
13136                         chk(io.EOF)
13137                 }
13138                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOProps", err))
13139         }
13140 }
13141
13142 func (obj *AOCmdProps) deserialize(r io.Reader) {
13143         if err := pcall(func() {
13144                 ((*(*(struct {
13145                         Props AOProps
13146                 }))(obj)).Props).deserialize(r)
13147         }); err != nil {
13148                 if err == io.EOF {
13149                         chk(io.EOF)
13150                 }
13151                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOProps", err))
13152         }
13153 }
13154
13155 func (obj *AOCmdPos) serialize(w io.Writer) {
13156         if err := pcall(func() {
13157                 ((*(*(struct {
13158                         Pos AOPos
13159                 }))(obj)).Pos).serialize(w)
13160         }); err != nil {
13161                 if err == io.EOF {
13162                         chk(io.EOF)
13163                 }
13164                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPos", err))
13165         }
13166 }
13167
13168 func (obj *AOCmdPos) deserialize(r io.Reader) {
13169         if err := pcall(func() {
13170                 ((*(*(struct {
13171                         Pos AOPos
13172                 }))(obj)).Pos).deserialize(r)
13173         }); err != nil {
13174                 if err == io.EOF {
13175                         chk(io.EOF)
13176                 }
13177                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPos", err))
13178         }
13179 }
13180
13181 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13182         if err := pcall(func() {
13183                 ((*(*(struct {
13184                         Mod Texture // suffix
13185                 }))(obj)).Mod).serialize(w)
13186         }); err != nil {
13187                 if err == io.EOF {
13188                         chk(io.EOF)
13189                 }
13190                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13191         }
13192 }
13193
13194 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13195         if err := pcall(func() {
13196                 ((*(*(struct {
13197                         Mod Texture // suffix
13198                 }))(obj)).Mod).deserialize(r)
13199         }); err != nil {
13200                 if err == io.EOF {
13201                         chk(io.EOF)
13202                 }
13203                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13204         }
13205 }
13206
13207 func (obj *AOCmdSprite) serialize(w io.Writer) {
13208         if err := pcall(func() {
13209                 ((*(*(struct {
13210                         Sprite AOSprite
13211                 }))(obj)).Sprite).serialize(w)
13212         }); err != nil {
13213                 if err == io.EOF {
13214                         chk(io.EOF)
13215                 }
13216                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOSprite", err))
13217         }
13218 }
13219
13220 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13221         if err := pcall(func() {
13222                 ((*(*(struct {
13223                         Sprite AOSprite
13224                 }))(obj)).Sprite).deserialize(r)
13225         }); err != nil {
13226                 if err == io.EOF {
13227                         chk(io.EOF)
13228                 }
13229                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOSprite", err))
13230         }
13231 }
13232
13233 func (obj *AOCmdHP) serialize(w io.Writer) {
13234         {
13235                 x := (*(*(struct {
13236                         HP uint16
13237                 }))(obj)).HP
13238                 write16(w, uint16(x))
13239         }
13240 }
13241
13242 func (obj *AOCmdHP) deserialize(r io.Reader) {
13243         {
13244                 p := &(*(*(struct {
13245                         HP uint16
13246                 }))(obj)).HP
13247                 *p = read16(r)
13248         }
13249 }
13250
13251 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13252         if len(((*(*(struct {
13253                 Armor []Group
13254         }))(obj)).Armor)) > math.MaxUint16 {
13255                 chk(ErrTooLong)
13256         }
13257         {
13258                 x := uint16(len(((*(*(struct {
13259                         Armor []Group
13260                 }))(obj)).Armor)))
13261                 write16(w, uint16(x))
13262         }
13263         for local225 := range (*(*(struct {
13264                 Armor []Group
13265         }))(obj)).Armor {
13266                 if err := pcall(func() {
13267                         (((*(*(struct {
13268                                 Armor []Group
13269                         }))(obj)).Armor)[local225]).serialize(w)
13270                 }); err != nil {
13271                         if err == io.EOF {
13272                                 chk(io.EOF)
13273                         }
13274                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
13275                 }
13276         }
13277 }
13278
13279 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13280         var local226 uint16
13281         {
13282                 p := &local226
13283                 *p = read16(r)
13284         }
13285         ((*(*(struct {
13286                 Armor []Group
13287         }))(obj)).Armor) = make([]Group, local226)
13288         for local227 := range (*(*(struct {
13289                 Armor []Group
13290         }))(obj)).Armor {
13291                 if err := pcall(func() {
13292                         (((*(*(struct {
13293                                 Armor []Group
13294                         }))(obj)).Armor)[local227]).deserialize(r)
13295                 }); err != nil {
13296                         if err == io.EOF {
13297                                 chk(io.EOF)
13298                         }
13299                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
13300                 }
13301         }
13302 }
13303
13304 func (obj *AOCmdAnim) serialize(w io.Writer) {
13305         if err := pcall(func() {
13306                 ((*(*(struct {
13307                         Anim AOAnim
13308                 }))(obj)).Anim).serialize(w)
13309         }); err != nil {
13310                 if err == io.EOF {
13311                         chk(io.EOF)
13312                 }
13313                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAnim", err))
13314         }
13315 }
13316
13317 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13318         if err := pcall(func() {
13319                 ((*(*(struct {
13320                         Anim AOAnim
13321                 }))(obj)).Anim).deserialize(r)
13322         }); err != nil {
13323                 if err == io.EOF {
13324                         chk(io.EOF)
13325                 }
13326                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAnim", err))
13327         }
13328 }
13329
13330 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13331         if len(([]byte((*(*(struct {
13332                 Bone string
13333                 Pos  AOBonePos
13334         }))(obj)).Bone))) > math.MaxUint16 {
13335                 chk(ErrTooLong)
13336         }
13337         {
13338                 x := uint16(len(([]byte((*(*(struct {
13339                         Bone string
13340                         Pos  AOBonePos
13341                 }))(obj)).Bone))))
13342                 write16(w, uint16(x))
13343         }
13344         {
13345                 _, err := w.Write(([]byte((*(*(struct {
13346                         Bone string
13347                         Pos  AOBonePos
13348                 }))(obj)).Bone))[:])
13349                 chk(err)
13350         }
13351         if err := pcall(func() {
13352                 ((*(*(struct {
13353                         Bone string
13354                         Pos  AOBonePos
13355                 }))(obj)).Pos).serialize(w)
13356         }); err != nil {
13357                 if err == io.EOF {
13358                         chk(io.EOF)
13359                 }
13360                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOBonePos", err))
13361         }
13362 }
13363
13364 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13365         var local228 []uint8
13366         var local229 uint16
13367         {
13368                 p := &local229
13369                 *p = read16(r)
13370         }
13371         (local228) = make([]uint8, local229)
13372         {
13373                 _, err := io.ReadFull(r, (local228)[:])
13374                 chk(err)
13375         }
13376         ((*(*(struct {
13377                 Bone string
13378                 Pos  AOBonePos
13379         }))(obj)).Bone) = string(local228)
13380         if err := pcall(func() {
13381                 ((*(*(struct {
13382                         Bone string
13383                         Pos  AOBonePos
13384                 }))(obj)).Pos).deserialize(r)
13385         }); err != nil {
13386                 if err == io.EOF {
13387                         chk(io.EOF)
13388                 }
13389                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOBonePos", err))
13390         }
13391 }
13392
13393 func (obj *AOCmdAttach) serialize(w io.Writer) {
13394         if err := pcall(func() {
13395                 ((*(*(struct {
13396                         Attach AOAttach
13397                 }))(obj)).Attach).serialize(w)
13398         }); err != nil {
13399                 if err == io.EOF {
13400                         chk(io.EOF)
13401                 }
13402                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAttach", err))
13403         }
13404 }
13405
13406 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13407         if err := pcall(func() {
13408                 ((*(*(struct {
13409                         Attach AOAttach
13410                 }))(obj)).Attach).deserialize(r)
13411         }); err != nil {
13412                 if err == io.EOF {
13413                         chk(io.EOF)
13414                 }
13415                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAttach", err))
13416         }
13417 }
13418
13419 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13420         if err := pcall(func() {
13421                 ((*(*(struct {
13422                         Phys AOPhysOverride
13423                 }))(obj)).Phys).serialize(w)
13424         }); err != nil {
13425                 if err == io.EOF {
13426                         chk(io.EOF)
13427                 }
13428                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPhysOverride", err))
13429         }
13430 }
13431
13432 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13433         if err := pcall(func() {
13434                 ((*(*(struct {
13435                         Phys AOPhysOverride
13436                 }))(obj)).Phys).deserialize(r)
13437         }); err != nil {
13438                 if err == io.EOF {
13439                         chk(io.EOF)
13440                 }
13441                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPhysOverride", err))
13442         }
13443 }
13444
13445 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13446         if err := pcall(func() {
13447                 ((*(*(struct {
13448                         ID AOID
13449                 }))(obj)).ID).serialize(w)
13450         }); err != nil {
13451                 if err == io.EOF {
13452                         chk(io.EOF)
13453                 }
13454                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
13455         }
13456         {
13457                 local230 := genericCAO
13458                 if err := pcall(func() {
13459                         (local230).serialize(w)
13460                 }); err != nil {
13461                         if err == io.EOF {
13462                                 chk(io.EOF)
13463                         }
13464                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
13465                 }
13466         }
13467 }
13468
13469 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13470         if err := pcall(func() {
13471                 ((*(*(struct {
13472                         ID AOID
13473                 }))(obj)).ID).deserialize(r)
13474         }); err != nil {
13475                 if err == io.EOF {
13476                         chk(io.EOF)
13477                 }
13478                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
13479         }
13480         {
13481                 var local231 aoType
13482                 local232 := genericCAO
13483                 if err := pcall(func() {
13484                         (local231).deserialize(r)
13485                 }); err != nil {
13486                         if err == io.EOF {
13487                                 chk(io.EOF)
13488                         }
13489                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
13490                 }
13491                 if local231 != local232 {
13492                         chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
13493                 }
13494         }
13495 }
13496
13497 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13498         {
13499                 x := (*(*(struct {
13500                         Speed float32
13501                 }))(obj)).Speed
13502                 write32(w, math.Float32bits(x))
13503         }
13504 }
13505
13506 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13507         {
13508                 p := &(*(*(struct {
13509                         Speed float32
13510                 }))(obj)).Speed
13511                 *p = math.Float32frombits(read32(r))
13512         }
13513 }
13514
13515 func (obj *NodeMeta) serialize(w io.Writer) {
13516         if len(((*(*(struct {
13517                 //mt:len32
13518                 Fields []NodeMetaField
13519
13520                 Inv Inv
13521         }))(obj)).Fields)) > math.MaxUint32 {
13522                 chk(ErrTooLong)
13523         }
13524         {
13525                 x := uint32(len(((*(*(struct {
13526                         //mt:len32
13527                         Fields []NodeMetaField
13528
13529                         Inv Inv
13530                 }))(obj)).Fields)))
13531                 write32(w, uint32(x))
13532         }
13533         for local233 := range (*(*(struct {
13534                 //mt:len32
13535                 Fields []NodeMetaField
13536
13537                 Inv Inv
13538         }))(obj)).Fields {
13539                 if err := pcall(func() {
13540                         (((*(*(struct {
13541                                 //mt:len32
13542                                 Fields []NodeMetaField
13543
13544                                 Inv Inv
13545                         }))(obj)).Fields)[local233]).serialize(w)
13546                 }); err != nil {
13547                         if err == io.EOF {
13548                                 chk(io.EOF)
13549                         }
13550                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeMetaField", err))
13551                 }
13552         }
13553         chk(((*(*(struct {
13554                 //mt:len32
13555                 Fields []NodeMetaField
13556
13557                 Inv Inv
13558         }))(obj)).Inv).Serialize(w))
13559 }
13560
13561 func (obj *NodeMeta) deserialize(r io.Reader) {
13562         var local234 uint32
13563         {
13564                 p := &local234
13565                 *p = read32(r)
13566         }
13567         ((*(*(struct {
13568                 //mt:len32
13569                 Fields []NodeMetaField
13570
13571                 Inv Inv
13572         }))(obj)).Fields) = make([]NodeMetaField, local234)
13573         for local235 := range (*(*(struct {
13574                 //mt:len32
13575                 Fields []NodeMetaField
13576
13577                 Inv Inv
13578         }))(obj)).Fields {
13579                 if err := pcall(func() {
13580                         (((*(*(struct {
13581                                 //mt:len32
13582                                 Fields []NodeMetaField
13583
13584                                 Inv Inv
13585                         }))(obj)).Fields)[local235]).deserialize(r)
13586                 }); err != nil {
13587                         if err == io.EOF {
13588                                 chk(io.EOF)
13589                         }
13590                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeMetaField", err))
13591                 }
13592         }
13593         chk(((*(*(struct {
13594                 //mt:len32
13595                 Fields []NodeMetaField
13596
13597                 Inv Inv
13598         }))(obj)).Inv).Deserialize(r))
13599 }
13600
13601 func (obj *MinimapMode) serialize(w io.Writer) {
13602         if err := pcall(func() {
13603                 ((*(*(struct {
13604                         Type  MinimapType
13605                         Label string
13606                         Size  uint16
13607                         Texture
13608                         Scale uint16
13609                 }))(obj)).Type).serialize(w)
13610         }); err != nil {
13611                 if err == io.EOF {
13612                         chk(io.EOF)
13613                 }
13614                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MinimapType", err))
13615         }
13616         if len(([]byte((*(*(struct {
13617                 Type  MinimapType
13618                 Label string
13619                 Size  uint16
13620                 Texture
13621                 Scale uint16
13622         }))(obj)).Label))) > math.MaxUint16 {
13623                 chk(ErrTooLong)
13624         }
13625         {
13626                 x := uint16(len(([]byte((*(*(struct {
13627                         Type  MinimapType
13628                         Label string
13629                         Size  uint16
13630                         Texture
13631                         Scale uint16
13632                 }))(obj)).Label))))
13633                 write16(w, uint16(x))
13634         }
13635         {
13636                 _, err := w.Write(([]byte((*(*(struct {
13637                         Type  MinimapType
13638                         Label string
13639                         Size  uint16
13640                         Texture
13641                         Scale uint16
13642                 }))(obj)).Label))[:])
13643                 chk(err)
13644         }
13645         {
13646                 x := (*(*(struct {
13647                         Type  MinimapType
13648                         Label string
13649                         Size  uint16
13650                         Texture
13651                         Scale uint16
13652                 }))(obj)).Size
13653                 write16(w, uint16(x))
13654         }
13655         if err := pcall(func() {
13656                 ((*(*(struct {
13657                         Type  MinimapType
13658                         Label string
13659                         Size  uint16
13660                         Texture
13661                         Scale uint16
13662                 }))(obj)).Texture).serialize(w)
13663         }); err != nil {
13664                 if err == io.EOF {
13665                         chk(io.EOF)
13666                 }
13667                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13668         }
13669         {
13670                 x := (*(*(struct {
13671                         Type  MinimapType
13672                         Label string
13673                         Size  uint16
13674                         Texture
13675                         Scale uint16
13676                 }))(obj)).Scale
13677                 write16(w, uint16(x))
13678         }
13679 }
13680
13681 func (obj *MinimapMode) deserialize(r io.Reader) {
13682         if err := pcall(func() {
13683                 ((*(*(struct {
13684                         Type  MinimapType
13685                         Label string
13686                         Size  uint16
13687                         Texture
13688                         Scale uint16
13689                 }))(obj)).Type).deserialize(r)
13690         }); err != nil {
13691                 if err == io.EOF {
13692                         chk(io.EOF)
13693                 }
13694                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MinimapType", err))
13695         }
13696         var local236 []uint8
13697         var local237 uint16
13698         {
13699                 p := &local237
13700                 *p = read16(r)
13701         }
13702         (local236) = make([]uint8, local237)
13703         {
13704                 _, err := io.ReadFull(r, (local236)[:])
13705                 chk(err)
13706         }
13707         ((*(*(struct {
13708                 Type  MinimapType
13709                 Label string
13710                 Size  uint16
13711                 Texture
13712                 Scale uint16
13713         }))(obj)).Label) = string(local236)
13714         {
13715                 p := &(*(*(struct {
13716                         Type  MinimapType
13717                         Label string
13718                         Size  uint16
13719                         Texture
13720                         Scale uint16
13721                 }))(obj)).Size
13722                 *p = read16(r)
13723         }
13724         if err := pcall(func() {
13725                 ((*(*(struct {
13726                         Type  MinimapType
13727                         Label string
13728                         Size  uint16
13729                         Texture
13730                         Scale uint16
13731                 }))(obj)).Texture).deserialize(r)
13732         }); err != nil {
13733                 if err == io.EOF {
13734                         chk(io.EOF)
13735                 }
13736                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13737         }
13738         {
13739                 p := &(*(*(struct {
13740                         Type  MinimapType
13741                         Label string
13742                         Size  uint16
13743                         Texture
13744                         Scale uint16
13745                 }))(obj)).Scale
13746                 *p = read16(r)
13747         }
13748 }
13749
13750 func (obj *NodeDef) serialize(w io.Writer) {
13751         if err := pcall(func() {
13752                 ((*(*(struct {
13753                         Param0 Content
13754
13755                         Name   string
13756                         Groups []Group
13757
13758                         P1Type   Param1Type
13759                         P2Type   Param2Type
13760                         DrawType DrawType
13761
13762                         Mesh  string
13763                         Scale float32
13764                         //mt:const uint8(6)
13765                         Tiles        [6]TileDef
13766                         OverlayTiles [6]TileDef
13767                         //mt:const uint8(6)
13768                         SpecialTiles [6]TileDef
13769
13770                         Color   color.NRGBA
13771                         Palette Texture
13772
13773                         Waving       WaveType
13774                         ConnectSides uint8
13775                         ConnectTo    []Content
13776                         InsideTint   color.NRGBA
13777                         Level        uint8 // Must be < 128.
13778
13779                         Translucent bool // Sunlight is scattered and becomes normal light.
13780                         Transparent bool // Sunlight isn't scattered.
13781                         LightSrc    uint8
13782
13783                         GndContent   bool
13784                         Collides     bool
13785                         Pointable    bool
13786                         Diggable     bool
13787                         Climbable    bool
13788                         Replaceable  bool
13789                         OnRightClick bool
13790
13791                         DmgPerSec int32
13792
13793                         LiquidType   LiquidType
13794                         FlowingAlt   string
13795                         SrcAlt       string
13796                         Viscosity    uint8 // 0-7
13797                         LiqRenewable bool
13798                         FlowRange    uint8
13799                         DrownDmg     uint8
13800                         Floodable    bool
13801
13802                         DrawBox, ColBox, SelBox NodeBox
13803
13804                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13805
13806                         LegacyFaceDir bool
13807                         LegacyMounted bool
13808
13809                         DigPredict string
13810
13811                         MaxLvl uint8
13812
13813                         AlphaUse
13814                 }))(obj)).Param0).serialize(w)
13815         }); err != nil {
13816                 if err == io.EOF {
13817                         chk(io.EOF)
13818                 }
13819                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
13820         }
13821         {
13822                 ow := w
13823                 w := new(bytes.Buffer)
13824                 {
13825                         local238 := uint8(13)
13826                         {
13827                                 x := local238
13828                                 write8(w, uint8(x))
13829                         }
13830                 }
13831                 if len(([]byte((*(*(struct {
13832                         Param0 Content
13833
13834                         Name   string
13835                         Groups []Group
13836
13837                         P1Type   Param1Type
13838                         P2Type   Param2Type
13839                         DrawType DrawType
13840
13841                         Mesh  string
13842                         Scale float32
13843                         //mt:const uint8(6)
13844                         Tiles        [6]TileDef
13845                         OverlayTiles [6]TileDef
13846                         //mt:const uint8(6)
13847                         SpecialTiles [6]TileDef
13848
13849                         Color   color.NRGBA
13850                         Palette Texture
13851
13852                         Waving       WaveType
13853                         ConnectSides uint8
13854                         ConnectTo    []Content
13855                         InsideTint   color.NRGBA
13856                         Level        uint8 // Must be < 128.
13857
13858                         Translucent bool // Sunlight is scattered and becomes normal light.
13859                         Transparent bool // Sunlight isn't scattered.
13860                         LightSrc    uint8
13861
13862                         GndContent   bool
13863                         Collides     bool
13864                         Pointable    bool
13865                         Diggable     bool
13866                         Climbable    bool
13867                         Replaceable  bool
13868                         OnRightClick bool
13869
13870                         DmgPerSec int32
13871
13872                         LiquidType   LiquidType
13873                         FlowingAlt   string
13874                         SrcAlt       string
13875                         Viscosity    uint8 // 0-7
13876                         LiqRenewable bool
13877                         FlowRange    uint8
13878                         DrownDmg     uint8
13879                         Floodable    bool
13880
13881                         DrawBox, ColBox, SelBox NodeBox
13882
13883                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13884
13885                         LegacyFaceDir bool
13886                         LegacyMounted bool
13887
13888                         DigPredict string
13889
13890                         MaxLvl uint8
13891
13892                         AlphaUse
13893                 }))(obj)).Name))) > math.MaxUint16 {
13894                         chk(ErrTooLong)
13895                 }
13896                 {
13897                         x := uint16(len(([]byte((*(*(struct {
13898                                 Param0 Content
13899
13900                                 Name   string
13901                                 Groups []Group
13902
13903                                 P1Type   Param1Type
13904                                 P2Type   Param2Type
13905                                 DrawType DrawType
13906
13907                                 Mesh  string
13908                                 Scale float32
13909                                 //mt:const uint8(6)
13910                                 Tiles        [6]TileDef
13911                                 OverlayTiles [6]TileDef
13912                                 //mt:const uint8(6)
13913                                 SpecialTiles [6]TileDef
13914
13915                                 Color   color.NRGBA
13916                                 Palette Texture
13917
13918                                 Waving       WaveType
13919                                 ConnectSides uint8
13920                                 ConnectTo    []Content
13921                                 InsideTint   color.NRGBA
13922                                 Level        uint8 // Must be < 128.
13923
13924                                 Translucent bool // Sunlight is scattered and becomes normal light.
13925                                 Transparent bool // Sunlight isn't scattered.
13926                                 LightSrc    uint8
13927
13928                                 GndContent   bool
13929                                 Collides     bool
13930                                 Pointable    bool
13931                                 Diggable     bool
13932                                 Climbable    bool
13933                                 Replaceable  bool
13934                                 OnRightClick bool
13935
13936                                 DmgPerSec int32
13937
13938                                 LiquidType   LiquidType
13939                                 FlowingAlt   string
13940                                 SrcAlt       string
13941                                 Viscosity    uint8 // 0-7
13942                                 LiqRenewable bool
13943                                 FlowRange    uint8
13944                                 DrownDmg     uint8
13945                                 Floodable    bool
13946
13947                                 DrawBox, ColBox, SelBox NodeBox
13948
13949                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
13950
13951                                 LegacyFaceDir bool
13952                                 LegacyMounted bool
13953
13954                                 DigPredict string
13955
13956                                 MaxLvl uint8
13957
13958                                 AlphaUse
13959                         }))(obj)).Name))))
13960                         write16(w, uint16(x))
13961                 }
13962                 {
13963                         _, err := w.Write(([]byte((*(*(struct {
13964                                 Param0 Content
13965
13966                                 Name   string
13967                                 Groups []Group
13968
13969                                 P1Type   Param1Type
13970                                 P2Type   Param2Type
13971                                 DrawType DrawType
13972
13973                                 Mesh  string
13974                                 Scale float32
13975                                 //mt:const uint8(6)
13976                                 Tiles        [6]TileDef
13977                                 OverlayTiles [6]TileDef
13978                                 //mt:const uint8(6)
13979                                 SpecialTiles [6]TileDef
13980
13981                                 Color   color.NRGBA
13982                                 Palette Texture
13983
13984                                 Waving       WaveType
13985                                 ConnectSides uint8
13986                                 ConnectTo    []Content
13987                                 InsideTint   color.NRGBA
13988                                 Level        uint8 // Must be < 128.
13989
13990                                 Translucent bool // Sunlight is scattered and becomes normal light.
13991                                 Transparent bool // Sunlight isn't scattered.
13992                                 LightSrc    uint8
13993
13994                                 GndContent   bool
13995                                 Collides     bool
13996                                 Pointable    bool
13997                                 Diggable     bool
13998                                 Climbable    bool
13999                                 Replaceable  bool
14000                                 OnRightClick bool
14001
14002                                 DmgPerSec int32
14003
14004                                 LiquidType   LiquidType
14005                                 FlowingAlt   string
14006                                 SrcAlt       string
14007                                 Viscosity    uint8 // 0-7
14008                                 LiqRenewable bool
14009                                 FlowRange    uint8
14010                                 DrownDmg     uint8
14011                                 Floodable    bool
14012
14013                                 DrawBox, ColBox, SelBox NodeBox
14014
14015                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14016
14017                                 LegacyFaceDir bool
14018                                 LegacyMounted bool
14019
14020                                 DigPredict string
14021
14022                                 MaxLvl uint8
14023
14024                                 AlphaUse
14025                         }))(obj)).Name))[:])
14026                         chk(err)
14027                 }
14028                 if len(((*(*(struct {
14029                         Param0 Content
14030
14031                         Name   string
14032                         Groups []Group
14033
14034                         P1Type   Param1Type
14035                         P2Type   Param2Type
14036                         DrawType DrawType
14037
14038                         Mesh  string
14039                         Scale float32
14040                         //mt:const uint8(6)
14041                         Tiles        [6]TileDef
14042                         OverlayTiles [6]TileDef
14043                         //mt:const uint8(6)
14044                         SpecialTiles [6]TileDef
14045
14046                         Color   color.NRGBA
14047                         Palette Texture
14048
14049                         Waving       WaveType
14050                         ConnectSides uint8
14051                         ConnectTo    []Content
14052                         InsideTint   color.NRGBA
14053                         Level        uint8 // Must be < 128.
14054
14055                         Translucent bool // Sunlight is scattered and becomes normal light.
14056                         Transparent bool // Sunlight isn't scattered.
14057                         LightSrc    uint8
14058
14059                         GndContent   bool
14060                         Collides     bool
14061                         Pointable    bool
14062                         Diggable     bool
14063                         Climbable    bool
14064                         Replaceable  bool
14065                         OnRightClick bool
14066
14067                         DmgPerSec int32
14068
14069                         LiquidType   LiquidType
14070                         FlowingAlt   string
14071                         SrcAlt       string
14072                         Viscosity    uint8 // 0-7
14073                         LiqRenewable bool
14074                         FlowRange    uint8
14075                         DrownDmg     uint8
14076                         Floodable    bool
14077
14078                         DrawBox, ColBox, SelBox NodeBox
14079
14080                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14081
14082                         LegacyFaceDir bool
14083                         LegacyMounted bool
14084
14085                         DigPredict string
14086
14087                         MaxLvl uint8
14088
14089                         AlphaUse
14090                 }))(obj)).Groups)) > math.MaxUint16 {
14091                         chk(ErrTooLong)
14092                 }
14093                 {
14094                         x := uint16(len(((*(*(struct {
14095                                 Param0 Content
14096
14097                                 Name   string
14098                                 Groups []Group
14099
14100                                 P1Type   Param1Type
14101                                 P2Type   Param2Type
14102                                 DrawType DrawType
14103
14104                                 Mesh  string
14105                                 Scale float32
14106                                 //mt:const uint8(6)
14107                                 Tiles        [6]TileDef
14108                                 OverlayTiles [6]TileDef
14109                                 //mt:const uint8(6)
14110                                 SpecialTiles [6]TileDef
14111
14112                                 Color   color.NRGBA
14113                                 Palette Texture
14114
14115                                 Waving       WaveType
14116                                 ConnectSides uint8
14117                                 ConnectTo    []Content
14118                                 InsideTint   color.NRGBA
14119                                 Level        uint8 // Must be < 128.
14120
14121                                 Translucent bool // Sunlight is scattered and becomes normal light.
14122                                 Transparent bool // Sunlight isn't scattered.
14123                                 LightSrc    uint8
14124
14125                                 GndContent   bool
14126                                 Collides     bool
14127                                 Pointable    bool
14128                                 Diggable     bool
14129                                 Climbable    bool
14130                                 Replaceable  bool
14131                                 OnRightClick bool
14132
14133                                 DmgPerSec int32
14134
14135                                 LiquidType   LiquidType
14136                                 FlowingAlt   string
14137                                 SrcAlt       string
14138                                 Viscosity    uint8 // 0-7
14139                                 LiqRenewable bool
14140                                 FlowRange    uint8
14141                                 DrownDmg     uint8
14142                                 Floodable    bool
14143
14144                                 DrawBox, ColBox, SelBox NodeBox
14145
14146                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14147
14148                                 LegacyFaceDir bool
14149                                 LegacyMounted bool
14150
14151                                 DigPredict string
14152
14153                                 MaxLvl uint8
14154
14155                                 AlphaUse
14156                         }))(obj)).Groups)))
14157                         write16(w, uint16(x))
14158                 }
14159                 for local239 := range (*(*(struct {
14160                         Param0 Content
14161
14162                         Name   string
14163                         Groups []Group
14164
14165                         P1Type   Param1Type
14166                         P2Type   Param2Type
14167                         DrawType DrawType
14168
14169                         Mesh  string
14170                         Scale float32
14171                         //mt:const uint8(6)
14172                         Tiles        [6]TileDef
14173                         OverlayTiles [6]TileDef
14174                         //mt:const uint8(6)
14175                         SpecialTiles [6]TileDef
14176
14177                         Color   color.NRGBA
14178                         Palette Texture
14179
14180                         Waving       WaveType
14181                         ConnectSides uint8
14182                         ConnectTo    []Content
14183                         InsideTint   color.NRGBA
14184                         Level        uint8 // Must be < 128.
14185
14186                         Translucent bool // Sunlight is scattered and becomes normal light.
14187                         Transparent bool // Sunlight isn't scattered.
14188                         LightSrc    uint8
14189
14190                         GndContent   bool
14191                         Collides     bool
14192                         Pointable    bool
14193                         Diggable     bool
14194                         Climbable    bool
14195                         Replaceable  bool
14196                         OnRightClick bool
14197
14198                         DmgPerSec int32
14199
14200                         LiquidType   LiquidType
14201                         FlowingAlt   string
14202                         SrcAlt       string
14203                         Viscosity    uint8 // 0-7
14204                         LiqRenewable bool
14205                         FlowRange    uint8
14206                         DrownDmg     uint8
14207                         Floodable    bool
14208
14209                         DrawBox, ColBox, SelBox NodeBox
14210
14211                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14212
14213                         LegacyFaceDir bool
14214                         LegacyMounted bool
14215
14216                         DigPredict string
14217
14218                         MaxLvl uint8
14219
14220                         AlphaUse
14221                 }))(obj)).Groups {
14222                         if err := pcall(func() {
14223                                 (((*(*(struct {
14224                                         Param0 Content
14225
14226                                         Name   string
14227                                         Groups []Group
14228
14229                                         P1Type   Param1Type
14230                                         P2Type   Param2Type
14231                                         DrawType DrawType
14232
14233                                         Mesh  string
14234                                         Scale float32
14235                                         //mt:const uint8(6)
14236                                         Tiles        [6]TileDef
14237                                         OverlayTiles [6]TileDef
14238                                         //mt:const uint8(6)
14239                                         SpecialTiles [6]TileDef
14240
14241                                         Color   color.NRGBA
14242                                         Palette Texture
14243
14244                                         Waving       WaveType
14245                                         ConnectSides uint8
14246                                         ConnectTo    []Content
14247                                         InsideTint   color.NRGBA
14248                                         Level        uint8 // Must be < 128.
14249
14250                                         Translucent bool // Sunlight is scattered and becomes normal light.
14251                                         Transparent bool // Sunlight isn't scattered.
14252                                         LightSrc    uint8
14253
14254                                         GndContent   bool
14255                                         Collides     bool
14256                                         Pointable    bool
14257                                         Diggable     bool
14258                                         Climbable    bool
14259                                         Replaceable  bool
14260                                         OnRightClick bool
14261
14262                                         DmgPerSec int32
14263
14264                                         LiquidType   LiquidType
14265                                         FlowingAlt   string
14266                                         SrcAlt       string
14267                                         Viscosity    uint8 // 0-7
14268                                         LiqRenewable bool
14269                                         FlowRange    uint8
14270                                         DrownDmg     uint8
14271                                         Floodable    bool
14272
14273                                         DrawBox, ColBox, SelBox NodeBox
14274
14275                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14276
14277                                         LegacyFaceDir bool
14278                                         LegacyMounted bool
14279
14280                                         DigPredict string
14281
14282                                         MaxLvl uint8
14283
14284                                         AlphaUse
14285                                 }))(obj)).Groups)[local239]).serialize(w)
14286                         }); err != nil {
14287                                 if err == io.EOF {
14288                                         chk(io.EOF)
14289                                 }
14290                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
14291                         }
14292                 }
14293                 if err := pcall(func() {
14294                         ((*(*(struct {
14295                                 Param0 Content
14296
14297                                 Name   string
14298                                 Groups []Group
14299
14300                                 P1Type   Param1Type
14301                                 P2Type   Param2Type
14302                                 DrawType DrawType
14303
14304                                 Mesh  string
14305                                 Scale float32
14306                                 //mt:const uint8(6)
14307                                 Tiles        [6]TileDef
14308                                 OverlayTiles [6]TileDef
14309                                 //mt:const uint8(6)
14310                                 SpecialTiles [6]TileDef
14311
14312                                 Color   color.NRGBA
14313                                 Palette Texture
14314
14315                                 Waving       WaveType
14316                                 ConnectSides uint8
14317                                 ConnectTo    []Content
14318                                 InsideTint   color.NRGBA
14319                                 Level        uint8 // Must be < 128.
14320
14321                                 Translucent bool // Sunlight is scattered and becomes normal light.
14322                                 Transparent bool // Sunlight isn't scattered.
14323                                 LightSrc    uint8
14324
14325                                 GndContent   bool
14326                                 Collides     bool
14327                                 Pointable    bool
14328                                 Diggable     bool
14329                                 Climbable    bool
14330                                 Replaceable  bool
14331                                 OnRightClick bool
14332
14333                                 DmgPerSec int32
14334
14335                                 LiquidType   LiquidType
14336                                 FlowingAlt   string
14337                                 SrcAlt       string
14338                                 Viscosity    uint8 // 0-7
14339                                 LiqRenewable bool
14340                                 FlowRange    uint8
14341                                 DrownDmg     uint8
14342                                 Floodable    bool
14343
14344                                 DrawBox, ColBox, SelBox NodeBox
14345
14346                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14347
14348                                 LegacyFaceDir bool
14349                                 LegacyMounted bool
14350
14351                                 DigPredict string
14352
14353                                 MaxLvl uint8
14354
14355                                 AlphaUse
14356                         }))(obj)).P1Type).serialize(w)
14357                 }); err != nil {
14358                         if err == io.EOF {
14359                                 chk(io.EOF)
14360                         }
14361                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param1Type", err))
14362                 }
14363                 if err := pcall(func() {
14364                         ((*(*(struct {
14365                                 Param0 Content
14366
14367                                 Name   string
14368                                 Groups []Group
14369
14370                                 P1Type   Param1Type
14371                                 P2Type   Param2Type
14372                                 DrawType DrawType
14373
14374                                 Mesh  string
14375                                 Scale float32
14376                                 //mt:const uint8(6)
14377                                 Tiles        [6]TileDef
14378                                 OverlayTiles [6]TileDef
14379                                 //mt:const uint8(6)
14380                                 SpecialTiles [6]TileDef
14381
14382                                 Color   color.NRGBA
14383                                 Palette Texture
14384
14385                                 Waving       WaveType
14386                                 ConnectSides uint8
14387                                 ConnectTo    []Content
14388                                 InsideTint   color.NRGBA
14389                                 Level        uint8 // Must be < 128.
14390
14391                                 Translucent bool // Sunlight is scattered and becomes normal light.
14392                                 Transparent bool // Sunlight isn't scattered.
14393                                 LightSrc    uint8
14394
14395                                 GndContent   bool
14396                                 Collides     bool
14397                                 Pointable    bool
14398                                 Diggable     bool
14399                                 Climbable    bool
14400                                 Replaceable  bool
14401                                 OnRightClick bool
14402
14403                                 DmgPerSec int32
14404
14405                                 LiquidType   LiquidType
14406                                 FlowingAlt   string
14407                                 SrcAlt       string
14408                                 Viscosity    uint8 // 0-7
14409                                 LiqRenewable bool
14410                                 FlowRange    uint8
14411                                 DrownDmg     uint8
14412                                 Floodable    bool
14413
14414                                 DrawBox, ColBox, SelBox NodeBox
14415
14416                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14417
14418                                 LegacyFaceDir bool
14419                                 LegacyMounted bool
14420
14421                                 DigPredict string
14422
14423                                 MaxLvl uint8
14424
14425                                 AlphaUse
14426                         }))(obj)).P2Type).serialize(w)
14427                 }); err != nil {
14428                         if err == io.EOF {
14429                                 chk(io.EOF)
14430                         }
14431                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param2Type", err))
14432                 }
14433                 if err := pcall(func() {
14434                         ((*(*(struct {
14435                                 Param0 Content
14436
14437                                 Name   string
14438                                 Groups []Group
14439
14440                                 P1Type   Param1Type
14441                                 P2Type   Param2Type
14442                                 DrawType DrawType
14443
14444                                 Mesh  string
14445                                 Scale float32
14446                                 //mt:const uint8(6)
14447                                 Tiles        [6]TileDef
14448                                 OverlayTiles [6]TileDef
14449                                 //mt:const uint8(6)
14450                                 SpecialTiles [6]TileDef
14451
14452                                 Color   color.NRGBA
14453                                 Palette Texture
14454
14455                                 Waving       WaveType
14456                                 ConnectSides uint8
14457                                 ConnectTo    []Content
14458                                 InsideTint   color.NRGBA
14459                                 Level        uint8 // Must be < 128.
14460
14461                                 Translucent bool // Sunlight is scattered and becomes normal light.
14462                                 Transparent bool // Sunlight isn't scattered.
14463                                 LightSrc    uint8
14464
14465                                 GndContent   bool
14466                                 Collides     bool
14467                                 Pointable    bool
14468                                 Diggable     bool
14469                                 Climbable    bool
14470                                 Replaceable  bool
14471                                 OnRightClick bool
14472
14473                                 DmgPerSec int32
14474
14475                                 LiquidType   LiquidType
14476                                 FlowingAlt   string
14477                                 SrcAlt       string
14478                                 Viscosity    uint8 // 0-7
14479                                 LiqRenewable bool
14480                                 FlowRange    uint8
14481                                 DrownDmg     uint8
14482                                 Floodable    bool
14483
14484                                 DrawBox, ColBox, SelBox NodeBox
14485
14486                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14487
14488                                 LegacyFaceDir bool
14489                                 LegacyMounted bool
14490
14491                                 DigPredict string
14492
14493                                 MaxLvl uint8
14494
14495                                 AlphaUse
14496                         }))(obj)).DrawType).serialize(w)
14497                 }); err != nil {
14498                         if err == io.EOF {
14499                                 chk(io.EOF)
14500                         }
14501                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DrawType", err))
14502                 }
14503                 if len(([]byte((*(*(struct {
14504                         Param0 Content
14505
14506                         Name   string
14507                         Groups []Group
14508
14509                         P1Type   Param1Type
14510                         P2Type   Param2Type
14511                         DrawType DrawType
14512
14513                         Mesh  string
14514                         Scale float32
14515                         //mt:const uint8(6)
14516                         Tiles        [6]TileDef
14517                         OverlayTiles [6]TileDef
14518                         //mt:const uint8(6)
14519                         SpecialTiles [6]TileDef
14520
14521                         Color   color.NRGBA
14522                         Palette Texture
14523
14524                         Waving       WaveType
14525                         ConnectSides uint8
14526                         ConnectTo    []Content
14527                         InsideTint   color.NRGBA
14528                         Level        uint8 // Must be < 128.
14529
14530                         Translucent bool // Sunlight is scattered and becomes normal light.
14531                         Transparent bool // Sunlight isn't scattered.
14532                         LightSrc    uint8
14533
14534                         GndContent   bool
14535                         Collides     bool
14536                         Pointable    bool
14537                         Diggable     bool
14538                         Climbable    bool
14539                         Replaceable  bool
14540                         OnRightClick bool
14541
14542                         DmgPerSec int32
14543
14544                         LiquidType   LiquidType
14545                         FlowingAlt   string
14546                         SrcAlt       string
14547                         Viscosity    uint8 // 0-7
14548                         LiqRenewable bool
14549                         FlowRange    uint8
14550                         DrownDmg     uint8
14551                         Floodable    bool
14552
14553                         DrawBox, ColBox, SelBox NodeBox
14554
14555                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14556
14557                         LegacyFaceDir bool
14558                         LegacyMounted bool
14559
14560                         DigPredict string
14561
14562                         MaxLvl uint8
14563
14564                         AlphaUse
14565                 }))(obj)).Mesh))) > math.MaxUint16 {
14566                         chk(ErrTooLong)
14567                 }
14568                 {
14569                         x := uint16(len(([]byte((*(*(struct {
14570                                 Param0 Content
14571
14572                                 Name   string
14573                                 Groups []Group
14574
14575                                 P1Type   Param1Type
14576                                 P2Type   Param2Type
14577                                 DrawType DrawType
14578
14579                                 Mesh  string
14580                                 Scale float32
14581                                 //mt:const uint8(6)
14582                                 Tiles        [6]TileDef
14583                                 OverlayTiles [6]TileDef
14584                                 //mt:const uint8(6)
14585                                 SpecialTiles [6]TileDef
14586
14587                                 Color   color.NRGBA
14588                                 Palette Texture
14589
14590                                 Waving       WaveType
14591                                 ConnectSides uint8
14592                                 ConnectTo    []Content
14593                                 InsideTint   color.NRGBA
14594                                 Level        uint8 // Must be < 128.
14595
14596                                 Translucent bool // Sunlight is scattered and becomes normal light.
14597                                 Transparent bool // Sunlight isn't scattered.
14598                                 LightSrc    uint8
14599
14600                                 GndContent   bool
14601                                 Collides     bool
14602                                 Pointable    bool
14603                                 Diggable     bool
14604                                 Climbable    bool
14605                                 Replaceable  bool
14606                                 OnRightClick bool
14607
14608                                 DmgPerSec int32
14609
14610                                 LiquidType   LiquidType
14611                                 FlowingAlt   string
14612                                 SrcAlt       string
14613                                 Viscosity    uint8 // 0-7
14614                                 LiqRenewable bool
14615                                 FlowRange    uint8
14616                                 DrownDmg     uint8
14617                                 Floodable    bool
14618
14619                                 DrawBox, ColBox, SelBox NodeBox
14620
14621                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14622
14623                                 LegacyFaceDir bool
14624                                 LegacyMounted bool
14625
14626                                 DigPredict string
14627
14628                                 MaxLvl uint8
14629
14630                                 AlphaUse
14631                         }))(obj)).Mesh))))
14632                         write16(w, uint16(x))
14633                 }
14634                 {
14635                         _, err := w.Write(([]byte((*(*(struct {
14636                                 Param0 Content
14637
14638                                 Name   string
14639                                 Groups []Group
14640
14641                                 P1Type   Param1Type
14642                                 P2Type   Param2Type
14643                                 DrawType DrawType
14644
14645                                 Mesh  string
14646                                 Scale float32
14647                                 //mt:const uint8(6)
14648                                 Tiles        [6]TileDef
14649                                 OverlayTiles [6]TileDef
14650                                 //mt:const uint8(6)
14651                                 SpecialTiles [6]TileDef
14652
14653                                 Color   color.NRGBA
14654                                 Palette Texture
14655
14656                                 Waving       WaveType
14657                                 ConnectSides uint8
14658                                 ConnectTo    []Content
14659                                 InsideTint   color.NRGBA
14660                                 Level        uint8 // Must be < 128.
14661
14662                                 Translucent bool // Sunlight is scattered and becomes normal light.
14663                                 Transparent bool // Sunlight isn't scattered.
14664                                 LightSrc    uint8
14665
14666                                 GndContent   bool
14667                                 Collides     bool
14668                                 Pointable    bool
14669                                 Diggable     bool
14670                                 Climbable    bool
14671                                 Replaceable  bool
14672                                 OnRightClick bool
14673
14674                                 DmgPerSec int32
14675
14676                                 LiquidType   LiquidType
14677                                 FlowingAlt   string
14678                                 SrcAlt       string
14679                                 Viscosity    uint8 // 0-7
14680                                 LiqRenewable bool
14681                                 FlowRange    uint8
14682                                 DrownDmg     uint8
14683                                 Floodable    bool
14684
14685                                 DrawBox, ColBox, SelBox NodeBox
14686
14687                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14688
14689                                 LegacyFaceDir bool
14690                                 LegacyMounted bool
14691
14692                                 DigPredict string
14693
14694                                 MaxLvl uint8
14695
14696                                 AlphaUse
14697                         }))(obj)).Mesh))[:])
14698                         chk(err)
14699                 }
14700                 {
14701                         x := (*(*(struct {
14702                                 Param0 Content
14703
14704                                 Name   string
14705                                 Groups []Group
14706
14707                                 P1Type   Param1Type
14708                                 P2Type   Param2Type
14709                                 DrawType DrawType
14710
14711                                 Mesh  string
14712                                 Scale float32
14713                                 //mt:const uint8(6)
14714                                 Tiles        [6]TileDef
14715                                 OverlayTiles [6]TileDef
14716                                 //mt:const uint8(6)
14717                                 SpecialTiles [6]TileDef
14718
14719                                 Color   color.NRGBA
14720                                 Palette Texture
14721
14722                                 Waving       WaveType
14723                                 ConnectSides uint8
14724                                 ConnectTo    []Content
14725                                 InsideTint   color.NRGBA
14726                                 Level        uint8 // Must be < 128.
14727
14728                                 Translucent bool // Sunlight is scattered and becomes normal light.
14729                                 Transparent bool // Sunlight isn't scattered.
14730                                 LightSrc    uint8
14731
14732                                 GndContent   bool
14733                                 Collides     bool
14734                                 Pointable    bool
14735                                 Diggable     bool
14736                                 Climbable    bool
14737                                 Replaceable  bool
14738                                 OnRightClick bool
14739
14740                                 DmgPerSec int32
14741
14742                                 LiquidType   LiquidType
14743                                 FlowingAlt   string
14744                                 SrcAlt       string
14745                                 Viscosity    uint8 // 0-7
14746                                 LiqRenewable bool
14747                                 FlowRange    uint8
14748                                 DrownDmg     uint8
14749                                 Floodable    bool
14750
14751                                 DrawBox, ColBox, SelBox NodeBox
14752
14753                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14754
14755                                 LegacyFaceDir bool
14756                                 LegacyMounted bool
14757
14758                                 DigPredict string
14759
14760                                 MaxLvl uint8
14761
14762                                 AlphaUse
14763                         }))(obj)).Scale
14764                         write32(w, math.Float32bits(x))
14765                 }
14766                 {
14767                         local240 := uint8(6)
14768                         {
14769                                 x := local240
14770                                 write8(w, uint8(x))
14771                         }
14772                 }
14773                 for local241 := range (*(*(struct {
14774                         Param0 Content
14775
14776                         Name   string
14777                         Groups []Group
14778
14779                         P1Type   Param1Type
14780                         P2Type   Param2Type
14781                         DrawType DrawType
14782
14783                         Mesh  string
14784                         Scale float32
14785                         //mt:const uint8(6)
14786                         Tiles        [6]TileDef
14787                         OverlayTiles [6]TileDef
14788                         //mt:const uint8(6)
14789                         SpecialTiles [6]TileDef
14790
14791                         Color   color.NRGBA
14792                         Palette Texture
14793
14794                         Waving       WaveType
14795                         ConnectSides uint8
14796                         ConnectTo    []Content
14797                         InsideTint   color.NRGBA
14798                         Level        uint8 // Must be < 128.
14799
14800                         Translucent bool // Sunlight is scattered and becomes normal light.
14801                         Transparent bool // Sunlight isn't scattered.
14802                         LightSrc    uint8
14803
14804                         GndContent   bool
14805                         Collides     bool
14806                         Pointable    bool
14807                         Diggable     bool
14808                         Climbable    bool
14809                         Replaceable  bool
14810                         OnRightClick bool
14811
14812                         DmgPerSec int32
14813
14814                         LiquidType   LiquidType
14815                         FlowingAlt   string
14816                         SrcAlt       string
14817                         Viscosity    uint8 // 0-7
14818                         LiqRenewable bool
14819                         FlowRange    uint8
14820                         DrownDmg     uint8
14821                         Floodable    bool
14822
14823                         DrawBox, ColBox, SelBox NodeBox
14824
14825                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14826
14827                         LegacyFaceDir bool
14828                         LegacyMounted bool
14829
14830                         DigPredict string
14831
14832                         MaxLvl uint8
14833
14834                         AlphaUse
14835                 }))(obj)).Tiles {
14836                         if err := pcall(func() {
14837                                 (((*(*(struct {
14838                                         Param0 Content
14839
14840                                         Name   string
14841                                         Groups []Group
14842
14843                                         P1Type   Param1Type
14844                                         P2Type   Param2Type
14845                                         DrawType DrawType
14846
14847                                         Mesh  string
14848                                         Scale float32
14849                                         //mt:const uint8(6)
14850                                         Tiles        [6]TileDef
14851                                         OverlayTiles [6]TileDef
14852                                         //mt:const uint8(6)
14853                                         SpecialTiles [6]TileDef
14854
14855                                         Color   color.NRGBA
14856                                         Palette Texture
14857
14858                                         Waving       WaveType
14859                                         ConnectSides uint8
14860                                         ConnectTo    []Content
14861                                         InsideTint   color.NRGBA
14862                                         Level        uint8 // Must be < 128.
14863
14864                                         Translucent bool // Sunlight is scattered and becomes normal light.
14865                                         Transparent bool // Sunlight isn't scattered.
14866                                         LightSrc    uint8
14867
14868                                         GndContent   bool
14869                                         Collides     bool
14870                                         Pointable    bool
14871                                         Diggable     bool
14872                                         Climbable    bool
14873                                         Replaceable  bool
14874                                         OnRightClick bool
14875
14876                                         DmgPerSec int32
14877
14878                                         LiquidType   LiquidType
14879                                         FlowingAlt   string
14880                                         SrcAlt       string
14881                                         Viscosity    uint8 // 0-7
14882                                         LiqRenewable bool
14883                                         FlowRange    uint8
14884                                         DrownDmg     uint8
14885                                         Floodable    bool
14886
14887                                         DrawBox, ColBox, SelBox NodeBox
14888
14889                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14890
14891                                         LegacyFaceDir bool
14892                                         LegacyMounted bool
14893
14894                                         DigPredict string
14895
14896                                         MaxLvl uint8
14897
14898                                         AlphaUse
14899                                 }))(obj)).Tiles)[local241]).serialize(w)
14900                         }); err != nil {
14901                                 if err == io.EOF {
14902                                         chk(io.EOF)
14903                                 }
14904                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
14905                         }
14906                 }
14907                 for local242 := range (*(*(struct {
14908                         Param0 Content
14909
14910                         Name   string
14911                         Groups []Group
14912
14913                         P1Type   Param1Type
14914                         P2Type   Param2Type
14915                         DrawType DrawType
14916
14917                         Mesh  string
14918                         Scale float32
14919                         //mt:const uint8(6)
14920                         Tiles        [6]TileDef
14921                         OverlayTiles [6]TileDef
14922                         //mt:const uint8(6)
14923                         SpecialTiles [6]TileDef
14924
14925                         Color   color.NRGBA
14926                         Palette Texture
14927
14928                         Waving       WaveType
14929                         ConnectSides uint8
14930                         ConnectTo    []Content
14931                         InsideTint   color.NRGBA
14932                         Level        uint8 // Must be < 128.
14933
14934                         Translucent bool // Sunlight is scattered and becomes normal light.
14935                         Transparent bool // Sunlight isn't scattered.
14936                         LightSrc    uint8
14937
14938                         GndContent   bool
14939                         Collides     bool
14940                         Pointable    bool
14941                         Diggable     bool
14942                         Climbable    bool
14943                         Replaceable  bool
14944                         OnRightClick bool
14945
14946                         DmgPerSec int32
14947
14948                         LiquidType   LiquidType
14949                         FlowingAlt   string
14950                         SrcAlt       string
14951                         Viscosity    uint8 // 0-7
14952                         LiqRenewable bool
14953                         FlowRange    uint8
14954                         DrownDmg     uint8
14955                         Floodable    bool
14956
14957                         DrawBox, ColBox, SelBox NodeBox
14958
14959                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14960
14961                         LegacyFaceDir bool
14962                         LegacyMounted bool
14963
14964                         DigPredict string
14965
14966                         MaxLvl uint8
14967
14968                         AlphaUse
14969                 }))(obj)).OverlayTiles {
14970                         if err := pcall(func() {
14971                                 (((*(*(struct {
14972                                         Param0 Content
14973
14974                                         Name   string
14975                                         Groups []Group
14976
14977                                         P1Type   Param1Type
14978                                         P2Type   Param2Type
14979                                         DrawType DrawType
14980
14981                                         Mesh  string
14982                                         Scale float32
14983                                         //mt:const uint8(6)
14984                                         Tiles        [6]TileDef
14985                                         OverlayTiles [6]TileDef
14986                                         //mt:const uint8(6)
14987                                         SpecialTiles [6]TileDef
14988
14989                                         Color   color.NRGBA
14990                                         Palette Texture
14991
14992                                         Waving       WaveType
14993                                         ConnectSides uint8
14994                                         ConnectTo    []Content
14995                                         InsideTint   color.NRGBA
14996                                         Level        uint8 // Must be < 128.
14997
14998                                         Translucent bool // Sunlight is scattered and becomes normal light.
14999                                         Transparent bool // Sunlight isn't scattered.
15000                                         LightSrc    uint8
15001
15002                                         GndContent   bool
15003                                         Collides     bool
15004                                         Pointable    bool
15005                                         Diggable     bool
15006                                         Climbable    bool
15007                                         Replaceable  bool
15008                                         OnRightClick bool
15009
15010                                         DmgPerSec int32
15011
15012                                         LiquidType   LiquidType
15013                                         FlowingAlt   string
15014                                         SrcAlt       string
15015                                         Viscosity    uint8 // 0-7
15016                                         LiqRenewable bool
15017                                         FlowRange    uint8
15018                                         DrownDmg     uint8
15019                                         Floodable    bool
15020
15021                                         DrawBox, ColBox, SelBox NodeBox
15022
15023                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15024
15025                                         LegacyFaceDir bool
15026                                         LegacyMounted bool
15027
15028                                         DigPredict string
15029
15030                                         MaxLvl uint8
15031
15032                                         AlphaUse
15033                                 }))(obj)).OverlayTiles)[local242]).serialize(w)
15034                         }); err != nil {
15035                                 if err == io.EOF {
15036                                         chk(io.EOF)
15037                                 }
15038                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
15039                         }
15040                 }
15041                 {
15042                         local243 := uint8(6)
15043                         {
15044                                 x := local243
15045                                 write8(w, uint8(x))
15046                         }
15047                 }
15048                 for local244 := range (*(*(struct {
15049                         Param0 Content
15050
15051                         Name   string
15052                         Groups []Group
15053
15054                         P1Type   Param1Type
15055                         P2Type   Param2Type
15056                         DrawType DrawType
15057
15058                         Mesh  string
15059                         Scale float32
15060                         //mt:const uint8(6)
15061                         Tiles        [6]TileDef
15062                         OverlayTiles [6]TileDef
15063                         //mt:const uint8(6)
15064                         SpecialTiles [6]TileDef
15065
15066                         Color   color.NRGBA
15067                         Palette Texture
15068
15069                         Waving       WaveType
15070                         ConnectSides uint8
15071                         ConnectTo    []Content
15072                         InsideTint   color.NRGBA
15073                         Level        uint8 // Must be < 128.
15074
15075                         Translucent bool // Sunlight is scattered and becomes normal light.
15076                         Transparent bool // Sunlight isn't scattered.
15077                         LightSrc    uint8
15078
15079                         GndContent   bool
15080                         Collides     bool
15081                         Pointable    bool
15082                         Diggable     bool
15083                         Climbable    bool
15084                         Replaceable  bool
15085                         OnRightClick bool
15086
15087                         DmgPerSec int32
15088
15089                         LiquidType   LiquidType
15090                         FlowingAlt   string
15091                         SrcAlt       string
15092                         Viscosity    uint8 // 0-7
15093                         LiqRenewable bool
15094                         FlowRange    uint8
15095                         DrownDmg     uint8
15096                         Floodable    bool
15097
15098                         DrawBox, ColBox, SelBox NodeBox
15099
15100                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15101
15102                         LegacyFaceDir bool
15103                         LegacyMounted bool
15104
15105                         DigPredict string
15106
15107                         MaxLvl uint8
15108
15109                         AlphaUse
15110                 }))(obj)).SpecialTiles {
15111                         if err := pcall(func() {
15112                                 (((*(*(struct {
15113                                         Param0 Content
15114
15115                                         Name   string
15116                                         Groups []Group
15117
15118                                         P1Type   Param1Type
15119                                         P2Type   Param2Type
15120                                         DrawType DrawType
15121
15122                                         Mesh  string
15123                                         Scale float32
15124                                         //mt:const uint8(6)
15125                                         Tiles        [6]TileDef
15126                                         OverlayTiles [6]TileDef
15127                                         //mt:const uint8(6)
15128                                         SpecialTiles [6]TileDef
15129
15130                                         Color   color.NRGBA
15131                                         Palette Texture
15132
15133                                         Waving       WaveType
15134                                         ConnectSides uint8
15135                                         ConnectTo    []Content
15136                                         InsideTint   color.NRGBA
15137                                         Level        uint8 // Must be < 128.
15138
15139                                         Translucent bool // Sunlight is scattered and becomes normal light.
15140                                         Transparent bool // Sunlight isn't scattered.
15141                                         LightSrc    uint8
15142
15143                                         GndContent   bool
15144                                         Collides     bool
15145                                         Pointable    bool
15146                                         Diggable     bool
15147                                         Climbable    bool
15148                                         Replaceable  bool
15149                                         OnRightClick bool
15150
15151                                         DmgPerSec int32
15152
15153                                         LiquidType   LiquidType
15154                                         FlowingAlt   string
15155                                         SrcAlt       string
15156                                         Viscosity    uint8 // 0-7
15157                                         LiqRenewable bool
15158                                         FlowRange    uint8
15159                                         DrownDmg     uint8
15160                                         Floodable    bool
15161
15162                                         DrawBox, ColBox, SelBox NodeBox
15163
15164                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15165
15166                                         LegacyFaceDir bool
15167                                         LegacyMounted bool
15168
15169                                         DigPredict string
15170
15171                                         MaxLvl uint8
15172
15173                                         AlphaUse
15174                                 }))(obj)).SpecialTiles)[local244]).serialize(w)
15175                         }); err != nil {
15176                                 if err == io.EOF {
15177                                         chk(io.EOF)
15178                                 }
15179                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
15180                         }
15181                 }
15182                 {
15183                         x := (*(*(struct {
15184                                 Param0 Content
15185
15186                                 Name   string
15187                                 Groups []Group
15188
15189                                 P1Type   Param1Type
15190                                 P2Type   Param2Type
15191                                 DrawType DrawType
15192
15193                                 Mesh  string
15194                                 Scale float32
15195                                 //mt:const uint8(6)
15196                                 Tiles        [6]TileDef
15197                                 OverlayTiles [6]TileDef
15198                                 //mt:const uint8(6)
15199                                 SpecialTiles [6]TileDef
15200
15201                                 Color   color.NRGBA
15202                                 Palette Texture
15203
15204                                 Waving       WaveType
15205                                 ConnectSides uint8
15206                                 ConnectTo    []Content
15207                                 InsideTint   color.NRGBA
15208                                 Level        uint8 // Must be < 128.
15209
15210                                 Translucent bool // Sunlight is scattered and becomes normal light.
15211                                 Transparent bool // Sunlight isn't scattered.
15212                                 LightSrc    uint8
15213
15214                                 GndContent   bool
15215                                 Collides     bool
15216                                 Pointable    bool
15217                                 Diggable     bool
15218                                 Climbable    bool
15219                                 Replaceable  bool
15220                                 OnRightClick bool
15221
15222                                 DmgPerSec int32
15223
15224                                 LiquidType   LiquidType
15225                                 FlowingAlt   string
15226                                 SrcAlt       string
15227                                 Viscosity    uint8 // 0-7
15228                                 LiqRenewable bool
15229                                 FlowRange    uint8
15230                                 DrownDmg     uint8
15231                                 Floodable    bool
15232
15233                                 DrawBox, ColBox, SelBox NodeBox
15234
15235                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15236
15237                                 LegacyFaceDir bool
15238                                 LegacyMounted bool
15239
15240                                 DigPredict string
15241
15242                                 MaxLvl uint8
15243
15244                                 AlphaUse
15245                         }))(obj)).Color
15246                         w.Write([]byte{x.A, x.R, x.G, x.B})
15247                 }
15248                 if err := pcall(func() {
15249                         ((*(*(struct {
15250                                 Param0 Content
15251
15252                                 Name   string
15253                                 Groups []Group
15254
15255                                 P1Type   Param1Type
15256                                 P2Type   Param2Type
15257                                 DrawType DrawType
15258
15259                                 Mesh  string
15260                                 Scale float32
15261                                 //mt:const uint8(6)
15262                                 Tiles        [6]TileDef
15263                                 OverlayTiles [6]TileDef
15264                                 //mt:const uint8(6)
15265                                 SpecialTiles [6]TileDef
15266
15267                                 Color   color.NRGBA
15268                                 Palette Texture
15269
15270                                 Waving       WaveType
15271                                 ConnectSides uint8
15272                                 ConnectTo    []Content
15273                                 InsideTint   color.NRGBA
15274                                 Level        uint8 // Must be < 128.
15275
15276                                 Translucent bool // Sunlight is scattered and becomes normal light.
15277                                 Transparent bool // Sunlight isn't scattered.
15278                                 LightSrc    uint8
15279
15280                                 GndContent   bool
15281                                 Collides     bool
15282                                 Pointable    bool
15283                                 Diggable     bool
15284                                 Climbable    bool
15285                                 Replaceable  bool
15286                                 OnRightClick bool
15287
15288                                 DmgPerSec int32
15289
15290                                 LiquidType   LiquidType
15291                                 FlowingAlt   string
15292                                 SrcAlt       string
15293                                 Viscosity    uint8 // 0-7
15294                                 LiqRenewable bool
15295                                 FlowRange    uint8
15296                                 DrownDmg     uint8
15297                                 Floodable    bool
15298
15299                                 DrawBox, ColBox, SelBox NodeBox
15300
15301                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15302
15303                                 LegacyFaceDir bool
15304                                 LegacyMounted bool
15305
15306                                 DigPredict string
15307
15308                                 MaxLvl uint8
15309
15310                                 AlphaUse
15311                         }))(obj)).Palette).serialize(w)
15312                 }); err != nil {
15313                         if err == io.EOF {
15314                                 chk(io.EOF)
15315                         }
15316                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
15317                 }
15318                 if err := pcall(func() {
15319                         ((*(*(struct {
15320                                 Param0 Content
15321
15322                                 Name   string
15323                                 Groups []Group
15324
15325                                 P1Type   Param1Type
15326                                 P2Type   Param2Type
15327                                 DrawType DrawType
15328
15329                                 Mesh  string
15330                                 Scale float32
15331                                 //mt:const uint8(6)
15332                                 Tiles        [6]TileDef
15333                                 OverlayTiles [6]TileDef
15334                                 //mt:const uint8(6)
15335                                 SpecialTiles [6]TileDef
15336
15337                                 Color   color.NRGBA
15338                                 Palette Texture
15339
15340                                 Waving       WaveType
15341                                 ConnectSides uint8
15342                                 ConnectTo    []Content
15343                                 InsideTint   color.NRGBA
15344                                 Level        uint8 // Must be < 128.
15345
15346                                 Translucent bool // Sunlight is scattered and becomes normal light.
15347                                 Transparent bool // Sunlight isn't scattered.
15348                                 LightSrc    uint8
15349
15350                                 GndContent   bool
15351                                 Collides     bool
15352                                 Pointable    bool
15353                                 Diggable     bool
15354                                 Climbable    bool
15355                                 Replaceable  bool
15356                                 OnRightClick bool
15357
15358                                 DmgPerSec int32
15359
15360                                 LiquidType   LiquidType
15361                                 FlowingAlt   string
15362                                 SrcAlt       string
15363                                 Viscosity    uint8 // 0-7
15364                                 LiqRenewable bool
15365                                 FlowRange    uint8
15366                                 DrownDmg     uint8
15367                                 Floodable    bool
15368
15369                                 DrawBox, ColBox, SelBox NodeBox
15370
15371                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15372
15373                                 LegacyFaceDir bool
15374                                 LegacyMounted bool
15375
15376                                 DigPredict string
15377
15378                                 MaxLvl uint8
15379
15380                                 AlphaUse
15381                         }))(obj)).Waving).serialize(w)
15382                 }); err != nil {
15383                         if err == io.EOF {
15384                                 chk(io.EOF)
15385                         }
15386                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.WaveType", err))
15387                 }
15388                 {
15389                         x := (*(*(struct {
15390                                 Param0 Content
15391
15392                                 Name   string
15393                                 Groups []Group
15394
15395                                 P1Type   Param1Type
15396                                 P2Type   Param2Type
15397                                 DrawType DrawType
15398
15399                                 Mesh  string
15400                                 Scale float32
15401                                 //mt:const uint8(6)
15402                                 Tiles        [6]TileDef
15403                                 OverlayTiles [6]TileDef
15404                                 //mt:const uint8(6)
15405                                 SpecialTiles [6]TileDef
15406
15407                                 Color   color.NRGBA
15408                                 Palette Texture
15409
15410                                 Waving       WaveType
15411                                 ConnectSides uint8
15412                                 ConnectTo    []Content
15413                                 InsideTint   color.NRGBA
15414                                 Level        uint8 // Must be < 128.
15415
15416                                 Translucent bool // Sunlight is scattered and becomes normal light.
15417                                 Transparent bool // Sunlight isn't scattered.
15418                                 LightSrc    uint8
15419
15420                                 GndContent   bool
15421                                 Collides     bool
15422                                 Pointable    bool
15423                                 Diggable     bool
15424                                 Climbable    bool
15425                                 Replaceable  bool
15426                                 OnRightClick bool
15427
15428                                 DmgPerSec int32
15429
15430                                 LiquidType   LiquidType
15431                                 FlowingAlt   string
15432                                 SrcAlt       string
15433                                 Viscosity    uint8 // 0-7
15434                                 LiqRenewable bool
15435                                 FlowRange    uint8
15436                                 DrownDmg     uint8
15437                                 Floodable    bool
15438
15439                                 DrawBox, ColBox, SelBox NodeBox
15440
15441                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15442
15443                                 LegacyFaceDir bool
15444                                 LegacyMounted bool
15445
15446                                 DigPredict string
15447
15448                                 MaxLvl uint8
15449
15450                                 AlphaUse
15451                         }))(obj)).ConnectSides
15452                         write8(w, uint8(x))
15453                 }
15454                 if len(((*(*(struct {
15455                         Param0 Content
15456
15457                         Name   string
15458                         Groups []Group
15459
15460                         P1Type   Param1Type
15461                         P2Type   Param2Type
15462                         DrawType DrawType
15463
15464                         Mesh  string
15465                         Scale float32
15466                         //mt:const uint8(6)
15467                         Tiles        [6]TileDef
15468                         OverlayTiles [6]TileDef
15469                         //mt:const uint8(6)
15470                         SpecialTiles [6]TileDef
15471
15472                         Color   color.NRGBA
15473                         Palette Texture
15474
15475                         Waving       WaveType
15476                         ConnectSides uint8
15477                         ConnectTo    []Content
15478                         InsideTint   color.NRGBA
15479                         Level        uint8 // Must be < 128.
15480
15481                         Translucent bool // Sunlight is scattered and becomes normal light.
15482                         Transparent bool // Sunlight isn't scattered.
15483                         LightSrc    uint8
15484
15485                         GndContent   bool
15486                         Collides     bool
15487                         Pointable    bool
15488                         Diggable     bool
15489                         Climbable    bool
15490                         Replaceable  bool
15491                         OnRightClick bool
15492
15493                         DmgPerSec int32
15494
15495                         LiquidType   LiquidType
15496                         FlowingAlt   string
15497                         SrcAlt       string
15498                         Viscosity    uint8 // 0-7
15499                         LiqRenewable bool
15500                         FlowRange    uint8
15501                         DrownDmg     uint8
15502                         Floodable    bool
15503
15504                         DrawBox, ColBox, SelBox NodeBox
15505
15506                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15507
15508                         LegacyFaceDir bool
15509                         LegacyMounted bool
15510
15511                         DigPredict string
15512
15513                         MaxLvl uint8
15514
15515                         AlphaUse
15516                 }))(obj)).ConnectTo)) > math.MaxUint16 {
15517                         chk(ErrTooLong)
15518                 }
15519                 {
15520                         x := uint16(len(((*(*(struct {
15521                                 Param0 Content
15522
15523                                 Name   string
15524                                 Groups []Group
15525
15526                                 P1Type   Param1Type
15527                                 P2Type   Param2Type
15528                                 DrawType DrawType
15529
15530                                 Mesh  string
15531                                 Scale float32
15532                                 //mt:const uint8(6)
15533                                 Tiles        [6]TileDef
15534                                 OverlayTiles [6]TileDef
15535                                 //mt:const uint8(6)
15536                                 SpecialTiles [6]TileDef
15537
15538                                 Color   color.NRGBA
15539                                 Palette Texture
15540
15541                                 Waving       WaveType
15542                                 ConnectSides uint8
15543                                 ConnectTo    []Content
15544                                 InsideTint   color.NRGBA
15545                                 Level        uint8 // Must be < 128.
15546
15547                                 Translucent bool // Sunlight is scattered and becomes normal light.
15548                                 Transparent bool // Sunlight isn't scattered.
15549                                 LightSrc    uint8
15550
15551                                 GndContent   bool
15552                                 Collides     bool
15553                                 Pointable    bool
15554                                 Diggable     bool
15555                                 Climbable    bool
15556                                 Replaceable  bool
15557                                 OnRightClick bool
15558
15559                                 DmgPerSec int32
15560
15561                                 LiquidType   LiquidType
15562                                 FlowingAlt   string
15563                                 SrcAlt       string
15564                                 Viscosity    uint8 // 0-7
15565                                 LiqRenewable bool
15566                                 FlowRange    uint8
15567                                 DrownDmg     uint8
15568                                 Floodable    bool
15569
15570                                 DrawBox, ColBox, SelBox NodeBox
15571
15572                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15573
15574                                 LegacyFaceDir bool
15575                                 LegacyMounted bool
15576
15577                                 DigPredict string
15578
15579                                 MaxLvl uint8
15580
15581                                 AlphaUse
15582                         }))(obj)).ConnectTo)))
15583                         write16(w, uint16(x))
15584                 }
15585                 for local245 := range (*(*(struct {
15586                         Param0 Content
15587
15588                         Name   string
15589                         Groups []Group
15590
15591                         P1Type   Param1Type
15592                         P2Type   Param2Type
15593                         DrawType DrawType
15594
15595                         Mesh  string
15596                         Scale float32
15597                         //mt:const uint8(6)
15598                         Tiles        [6]TileDef
15599                         OverlayTiles [6]TileDef
15600                         //mt:const uint8(6)
15601                         SpecialTiles [6]TileDef
15602
15603                         Color   color.NRGBA
15604                         Palette Texture
15605
15606                         Waving       WaveType
15607                         ConnectSides uint8
15608                         ConnectTo    []Content
15609                         InsideTint   color.NRGBA
15610                         Level        uint8 // Must be < 128.
15611
15612                         Translucent bool // Sunlight is scattered and becomes normal light.
15613                         Transparent bool // Sunlight isn't scattered.
15614                         LightSrc    uint8
15615
15616                         GndContent   bool
15617                         Collides     bool
15618                         Pointable    bool
15619                         Diggable     bool
15620                         Climbable    bool
15621                         Replaceable  bool
15622                         OnRightClick bool
15623
15624                         DmgPerSec int32
15625
15626                         LiquidType   LiquidType
15627                         FlowingAlt   string
15628                         SrcAlt       string
15629                         Viscosity    uint8 // 0-7
15630                         LiqRenewable bool
15631                         FlowRange    uint8
15632                         DrownDmg     uint8
15633                         Floodable    bool
15634
15635                         DrawBox, ColBox, SelBox NodeBox
15636
15637                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15638
15639                         LegacyFaceDir bool
15640                         LegacyMounted bool
15641
15642                         DigPredict string
15643
15644                         MaxLvl uint8
15645
15646                         AlphaUse
15647                 }))(obj)).ConnectTo {
15648                         if err := pcall(func() {
15649                                 (((*(*(struct {
15650                                         Param0 Content
15651
15652                                         Name   string
15653                                         Groups []Group
15654
15655                                         P1Type   Param1Type
15656                                         P2Type   Param2Type
15657                                         DrawType DrawType
15658
15659                                         Mesh  string
15660                                         Scale float32
15661                                         //mt:const uint8(6)
15662                                         Tiles        [6]TileDef
15663                                         OverlayTiles [6]TileDef
15664                                         //mt:const uint8(6)
15665                                         SpecialTiles [6]TileDef
15666
15667                                         Color   color.NRGBA
15668                                         Palette Texture
15669
15670                                         Waving       WaveType
15671                                         ConnectSides uint8
15672                                         ConnectTo    []Content
15673                                         InsideTint   color.NRGBA
15674                                         Level        uint8 // Must be < 128.
15675
15676                                         Translucent bool // Sunlight is scattered and becomes normal light.
15677                                         Transparent bool // Sunlight isn't scattered.
15678                                         LightSrc    uint8
15679
15680                                         GndContent   bool
15681                                         Collides     bool
15682                                         Pointable    bool
15683                                         Diggable     bool
15684                                         Climbable    bool
15685                                         Replaceable  bool
15686                                         OnRightClick bool
15687
15688                                         DmgPerSec int32
15689
15690                                         LiquidType   LiquidType
15691                                         FlowingAlt   string
15692                                         SrcAlt       string
15693                                         Viscosity    uint8 // 0-7
15694                                         LiqRenewable bool
15695                                         FlowRange    uint8
15696                                         DrownDmg     uint8
15697                                         Floodable    bool
15698
15699                                         DrawBox, ColBox, SelBox NodeBox
15700
15701                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15702
15703                                         LegacyFaceDir bool
15704                                         LegacyMounted bool
15705
15706                                         DigPredict string
15707
15708                                         MaxLvl uint8
15709
15710                                         AlphaUse
15711                                 }))(obj)).ConnectTo)[local245]).serialize(w)
15712                         }); err != nil {
15713                                 if err == io.EOF {
15714                                         chk(io.EOF)
15715                                 }
15716                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
15717                         }
15718                 }
15719                 {
15720                         x := (*(*(struct {
15721                                 Param0 Content
15722
15723                                 Name   string
15724                                 Groups []Group
15725
15726                                 P1Type   Param1Type
15727                                 P2Type   Param2Type
15728                                 DrawType DrawType
15729
15730                                 Mesh  string
15731                                 Scale float32
15732                                 //mt:const uint8(6)
15733                                 Tiles        [6]TileDef
15734                                 OverlayTiles [6]TileDef
15735                                 //mt:const uint8(6)
15736                                 SpecialTiles [6]TileDef
15737
15738                                 Color   color.NRGBA
15739                                 Palette Texture
15740
15741                                 Waving       WaveType
15742                                 ConnectSides uint8
15743                                 ConnectTo    []Content
15744                                 InsideTint   color.NRGBA
15745                                 Level        uint8 // Must be < 128.
15746
15747                                 Translucent bool // Sunlight is scattered and becomes normal light.
15748                                 Transparent bool // Sunlight isn't scattered.
15749                                 LightSrc    uint8
15750
15751                                 GndContent   bool
15752                                 Collides     bool
15753                                 Pointable    bool
15754                                 Diggable     bool
15755                                 Climbable    bool
15756                                 Replaceable  bool
15757                                 OnRightClick bool
15758
15759                                 DmgPerSec int32
15760
15761                                 LiquidType   LiquidType
15762                                 FlowingAlt   string
15763                                 SrcAlt       string
15764                                 Viscosity    uint8 // 0-7
15765                                 LiqRenewable bool
15766                                 FlowRange    uint8
15767                                 DrownDmg     uint8
15768                                 Floodable    bool
15769
15770                                 DrawBox, ColBox, SelBox NodeBox
15771
15772                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15773
15774                                 LegacyFaceDir bool
15775                                 LegacyMounted bool
15776
15777                                 DigPredict string
15778
15779                                 MaxLvl uint8
15780
15781                                 AlphaUse
15782                         }))(obj)).InsideTint
15783                         w.Write([]byte{x.A, x.R, x.G, x.B})
15784                 }
15785                 {
15786                         x := (*(*(struct {
15787                                 Param0 Content
15788
15789                                 Name   string
15790                                 Groups []Group
15791
15792                                 P1Type   Param1Type
15793                                 P2Type   Param2Type
15794                                 DrawType DrawType
15795
15796                                 Mesh  string
15797                                 Scale float32
15798                                 //mt:const uint8(6)
15799                                 Tiles        [6]TileDef
15800                                 OverlayTiles [6]TileDef
15801                                 //mt:const uint8(6)
15802                                 SpecialTiles [6]TileDef
15803
15804                                 Color   color.NRGBA
15805                                 Palette Texture
15806
15807                                 Waving       WaveType
15808                                 ConnectSides uint8
15809                                 ConnectTo    []Content
15810                                 InsideTint   color.NRGBA
15811                                 Level        uint8 // Must be < 128.
15812
15813                                 Translucent bool // Sunlight is scattered and becomes normal light.
15814                                 Transparent bool // Sunlight isn't scattered.
15815                                 LightSrc    uint8
15816
15817                                 GndContent   bool
15818                                 Collides     bool
15819                                 Pointable    bool
15820                                 Diggable     bool
15821                                 Climbable    bool
15822                                 Replaceable  bool
15823                                 OnRightClick bool
15824
15825                                 DmgPerSec int32
15826
15827                                 LiquidType   LiquidType
15828                                 FlowingAlt   string
15829                                 SrcAlt       string
15830                                 Viscosity    uint8 // 0-7
15831                                 LiqRenewable bool
15832                                 FlowRange    uint8
15833                                 DrownDmg     uint8
15834                                 Floodable    bool
15835
15836                                 DrawBox, ColBox, SelBox NodeBox
15837
15838                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15839
15840                                 LegacyFaceDir bool
15841                                 LegacyMounted bool
15842
15843                                 DigPredict string
15844
15845                                 MaxLvl uint8
15846
15847                                 AlphaUse
15848                         }))(obj)).Level
15849                         write8(w, uint8(x))
15850                 }
15851                 {
15852                         x := (*(*(struct {
15853                                 Param0 Content
15854
15855                                 Name   string
15856                                 Groups []Group
15857
15858                                 P1Type   Param1Type
15859                                 P2Type   Param2Type
15860                                 DrawType DrawType
15861
15862                                 Mesh  string
15863                                 Scale float32
15864                                 //mt:const uint8(6)
15865                                 Tiles        [6]TileDef
15866                                 OverlayTiles [6]TileDef
15867                                 //mt:const uint8(6)
15868                                 SpecialTiles [6]TileDef
15869
15870                                 Color   color.NRGBA
15871                                 Palette Texture
15872
15873                                 Waving       WaveType
15874                                 ConnectSides uint8
15875                                 ConnectTo    []Content
15876                                 InsideTint   color.NRGBA
15877                                 Level        uint8 // Must be < 128.
15878
15879                                 Translucent bool // Sunlight is scattered and becomes normal light.
15880                                 Transparent bool // Sunlight isn't scattered.
15881                                 LightSrc    uint8
15882
15883                                 GndContent   bool
15884                                 Collides     bool
15885                                 Pointable    bool
15886                                 Diggable     bool
15887                                 Climbable    bool
15888                                 Replaceable  bool
15889                                 OnRightClick bool
15890
15891                                 DmgPerSec int32
15892
15893                                 LiquidType   LiquidType
15894                                 FlowingAlt   string
15895                                 SrcAlt       string
15896                                 Viscosity    uint8 // 0-7
15897                                 LiqRenewable bool
15898                                 FlowRange    uint8
15899                                 DrownDmg     uint8
15900                                 Floodable    bool
15901
15902                                 DrawBox, ColBox, SelBox NodeBox
15903
15904                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15905
15906                                 LegacyFaceDir bool
15907                                 LegacyMounted bool
15908
15909                                 DigPredict string
15910
15911                                 MaxLvl uint8
15912
15913                                 AlphaUse
15914                         }))(obj)).Translucent
15915                         if x {
15916                                 write8(w, 1)
15917                         } else {
15918                                 write8(w, 0)
15919                         }
15920                 }
15921                 {
15922                         x := (*(*(struct {
15923                                 Param0 Content
15924
15925                                 Name   string
15926                                 Groups []Group
15927
15928                                 P1Type   Param1Type
15929                                 P2Type   Param2Type
15930                                 DrawType DrawType
15931
15932                                 Mesh  string
15933                                 Scale float32
15934                                 //mt:const uint8(6)
15935                                 Tiles        [6]TileDef
15936                                 OverlayTiles [6]TileDef
15937                                 //mt:const uint8(6)
15938                                 SpecialTiles [6]TileDef
15939
15940                                 Color   color.NRGBA
15941                                 Palette Texture
15942
15943                                 Waving       WaveType
15944                                 ConnectSides uint8
15945                                 ConnectTo    []Content
15946                                 InsideTint   color.NRGBA
15947                                 Level        uint8 // Must be < 128.
15948
15949                                 Translucent bool // Sunlight is scattered and becomes normal light.
15950                                 Transparent bool // Sunlight isn't scattered.
15951                                 LightSrc    uint8
15952
15953                                 GndContent   bool
15954                                 Collides     bool
15955                                 Pointable    bool
15956                                 Diggable     bool
15957                                 Climbable    bool
15958                                 Replaceable  bool
15959                                 OnRightClick bool
15960
15961                                 DmgPerSec int32
15962
15963                                 LiquidType   LiquidType
15964                                 FlowingAlt   string
15965                                 SrcAlt       string
15966                                 Viscosity    uint8 // 0-7
15967                                 LiqRenewable bool
15968                                 FlowRange    uint8
15969                                 DrownDmg     uint8
15970                                 Floodable    bool
15971
15972                                 DrawBox, ColBox, SelBox NodeBox
15973
15974                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15975
15976                                 LegacyFaceDir bool
15977                                 LegacyMounted bool
15978
15979                                 DigPredict string
15980
15981                                 MaxLvl uint8
15982
15983                                 AlphaUse
15984                         }))(obj)).Transparent
15985                         if x {
15986                                 write8(w, 1)
15987                         } else {
15988                                 write8(w, 0)
15989                         }
15990                 }
15991                 {
15992                         x := (*(*(struct {
15993                                 Param0 Content
15994
15995                                 Name   string
15996                                 Groups []Group
15997
15998                                 P1Type   Param1Type
15999                                 P2Type   Param2Type
16000                                 DrawType DrawType
16001
16002                                 Mesh  string
16003                                 Scale float32
16004                                 //mt:const uint8(6)
16005                                 Tiles        [6]TileDef
16006                                 OverlayTiles [6]TileDef
16007                                 //mt:const uint8(6)
16008                                 SpecialTiles [6]TileDef
16009
16010                                 Color   color.NRGBA
16011                                 Palette Texture
16012
16013                                 Waving       WaveType
16014                                 ConnectSides uint8
16015                                 ConnectTo    []Content
16016                                 InsideTint   color.NRGBA
16017                                 Level        uint8 // Must be < 128.
16018
16019                                 Translucent bool // Sunlight is scattered and becomes normal light.
16020                                 Transparent bool // Sunlight isn't scattered.
16021                                 LightSrc    uint8
16022
16023                                 GndContent   bool
16024                                 Collides     bool
16025                                 Pointable    bool
16026                                 Diggable     bool
16027                                 Climbable    bool
16028                                 Replaceable  bool
16029                                 OnRightClick bool
16030
16031                                 DmgPerSec int32
16032
16033                                 LiquidType   LiquidType
16034                                 FlowingAlt   string
16035                                 SrcAlt       string
16036                                 Viscosity    uint8 // 0-7
16037                                 LiqRenewable bool
16038                                 FlowRange    uint8
16039                                 DrownDmg     uint8
16040                                 Floodable    bool
16041
16042                                 DrawBox, ColBox, SelBox NodeBox
16043
16044                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16045
16046                                 LegacyFaceDir bool
16047                                 LegacyMounted bool
16048
16049                                 DigPredict string
16050
16051                                 MaxLvl uint8
16052
16053                                 AlphaUse
16054                         }))(obj)).LightSrc
16055                         write8(w, uint8(x))
16056                 }
16057                 {
16058                         x := (*(*(struct {
16059                                 Param0 Content
16060
16061                                 Name   string
16062                                 Groups []Group
16063
16064                                 P1Type   Param1Type
16065                                 P2Type   Param2Type
16066                                 DrawType DrawType
16067
16068                                 Mesh  string
16069                                 Scale float32
16070                                 //mt:const uint8(6)
16071                                 Tiles        [6]TileDef
16072                                 OverlayTiles [6]TileDef
16073                                 //mt:const uint8(6)
16074                                 SpecialTiles [6]TileDef
16075
16076                                 Color   color.NRGBA
16077                                 Palette Texture
16078
16079                                 Waving       WaveType
16080                                 ConnectSides uint8
16081                                 ConnectTo    []Content
16082                                 InsideTint   color.NRGBA
16083                                 Level        uint8 // Must be < 128.
16084
16085                                 Translucent bool // Sunlight is scattered and becomes normal light.
16086                                 Transparent bool // Sunlight isn't scattered.
16087                                 LightSrc    uint8
16088
16089                                 GndContent   bool
16090                                 Collides     bool
16091                                 Pointable    bool
16092                                 Diggable     bool
16093                                 Climbable    bool
16094                                 Replaceable  bool
16095                                 OnRightClick bool
16096
16097                                 DmgPerSec int32
16098
16099                                 LiquidType   LiquidType
16100                                 FlowingAlt   string
16101                                 SrcAlt       string
16102                                 Viscosity    uint8 // 0-7
16103                                 LiqRenewable bool
16104                                 FlowRange    uint8
16105                                 DrownDmg     uint8
16106                                 Floodable    bool
16107
16108                                 DrawBox, ColBox, SelBox NodeBox
16109
16110                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16111
16112                                 LegacyFaceDir bool
16113                                 LegacyMounted bool
16114
16115                                 DigPredict string
16116
16117                                 MaxLvl uint8
16118
16119                                 AlphaUse
16120                         }))(obj)).GndContent
16121                         if x {
16122                                 write8(w, 1)
16123                         } else {
16124                                 write8(w, 0)
16125                         }
16126                 }
16127                 {
16128                         x := (*(*(struct {
16129                                 Param0 Content
16130
16131                                 Name   string
16132                                 Groups []Group
16133
16134                                 P1Type   Param1Type
16135                                 P2Type   Param2Type
16136                                 DrawType DrawType
16137
16138                                 Mesh  string
16139                                 Scale float32
16140                                 //mt:const uint8(6)
16141                                 Tiles        [6]TileDef
16142                                 OverlayTiles [6]TileDef
16143                                 //mt:const uint8(6)
16144                                 SpecialTiles [6]TileDef
16145
16146                                 Color   color.NRGBA
16147                                 Palette Texture
16148
16149                                 Waving       WaveType
16150                                 ConnectSides uint8
16151                                 ConnectTo    []Content
16152                                 InsideTint   color.NRGBA
16153                                 Level        uint8 // Must be < 128.
16154
16155                                 Translucent bool // Sunlight is scattered and becomes normal light.
16156                                 Transparent bool // Sunlight isn't scattered.
16157                                 LightSrc    uint8
16158
16159                                 GndContent   bool
16160                                 Collides     bool
16161                                 Pointable    bool
16162                                 Diggable     bool
16163                                 Climbable    bool
16164                                 Replaceable  bool
16165                                 OnRightClick bool
16166
16167                                 DmgPerSec int32
16168
16169                                 LiquidType   LiquidType
16170                                 FlowingAlt   string
16171                                 SrcAlt       string
16172                                 Viscosity    uint8 // 0-7
16173                                 LiqRenewable bool
16174                                 FlowRange    uint8
16175                                 DrownDmg     uint8
16176                                 Floodable    bool
16177
16178                                 DrawBox, ColBox, SelBox NodeBox
16179
16180                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16181
16182                                 LegacyFaceDir bool
16183                                 LegacyMounted bool
16184
16185                                 DigPredict string
16186
16187                                 MaxLvl uint8
16188
16189                                 AlphaUse
16190                         }))(obj)).Collides
16191                         if x {
16192                                 write8(w, 1)
16193                         } else {
16194                                 write8(w, 0)
16195                         }
16196                 }
16197                 {
16198                         x := (*(*(struct {
16199                                 Param0 Content
16200
16201                                 Name   string
16202                                 Groups []Group
16203
16204                                 P1Type   Param1Type
16205                                 P2Type   Param2Type
16206                                 DrawType DrawType
16207
16208                                 Mesh  string
16209                                 Scale float32
16210                                 //mt:const uint8(6)
16211                                 Tiles        [6]TileDef
16212                                 OverlayTiles [6]TileDef
16213                                 //mt:const uint8(6)
16214                                 SpecialTiles [6]TileDef
16215
16216                                 Color   color.NRGBA
16217                                 Palette Texture
16218
16219                                 Waving       WaveType
16220                                 ConnectSides uint8
16221                                 ConnectTo    []Content
16222                                 InsideTint   color.NRGBA
16223                                 Level        uint8 // Must be < 128.
16224
16225                                 Translucent bool // Sunlight is scattered and becomes normal light.
16226                                 Transparent bool // Sunlight isn't scattered.
16227                                 LightSrc    uint8
16228
16229                                 GndContent   bool
16230                                 Collides     bool
16231                                 Pointable    bool
16232                                 Diggable     bool
16233                                 Climbable    bool
16234                                 Replaceable  bool
16235                                 OnRightClick bool
16236
16237                                 DmgPerSec int32
16238
16239                                 LiquidType   LiquidType
16240                                 FlowingAlt   string
16241                                 SrcAlt       string
16242                                 Viscosity    uint8 // 0-7
16243                                 LiqRenewable bool
16244                                 FlowRange    uint8
16245                                 DrownDmg     uint8
16246                                 Floodable    bool
16247
16248                                 DrawBox, ColBox, SelBox NodeBox
16249
16250                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16251
16252                                 LegacyFaceDir bool
16253                                 LegacyMounted bool
16254
16255                                 DigPredict string
16256
16257                                 MaxLvl uint8
16258
16259                                 AlphaUse
16260                         }))(obj)).Pointable
16261                         if x {
16262                                 write8(w, 1)
16263                         } else {
16264                                 write8(w, 0)
16265                         }
16266                 }
16267                 {
16268                         x := (*(*(struct {
16269                                 Param0 Content
16270
16271                                 Name   string
16272                                 Groups []Group
16273
16274                                 P1Type   Param1Type
16275                                 P2Type   Param2Type
16276                                 DrawType DrawType
16277
16278                                 Mesh  string
16279                                 Scale float32
16280                                 //mt:const uint8(6)
16281                                 Tiles        [6]TileDef
16282                                 OverlayTiles [6]TileDef
16283                                 //mt:const uint8(6)
16284                                 SpecialTiles [6]TileDef
16285
16286                                 Color   color.NRGBA
16287                                 Palette Texture
16288
16289                                 Waving       WaveType
16290                                 ConnectSides uint8
16291                                 ConnectTo    []Content
16292                                 InsideTint   color.NRGBA
16293                                 Level        uint8 // Must be < 128.
16294
16295                                 Translucent bool // Sunlight is scattered and becomes normal light.
16296                                 Transparent bool // Sunlight isn't scattered.
16297                                 LightSrc    uint8
16298
16299                                 GndContent   bool
16300                                 Collides     bool
16301                                 Pointable    bool
16302                                 Diggable     bool
16303                                 Climbable    bool
16304                                 Replaceable  bool
16305                                 OnRightClick bool
16306
16307                                 DmgPerSec int32
16308
16309                                 LiquidType   LiquidType
16310                                 FlowingAlt   string
16311                                 SrcAlt       string
16312                                 Viscosity    uint8 // 0-7
16313                                 LiqRenewable bool
16314                                 FlowRange    uint8
16315                                 DrownDmg     uint8
16316                                 Floodable    bool
16317
16318                                 DrawBox, ColBox, SelBox NodeBox
16319
16320                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16321
16322                                 LegacyFaceDir bool
16323                                 LegacyMounted bool
16324
16325                                 DigPredict string
16326
16327                                 MaxLvl uint8
16328
16329                                 AlphaUse
16330                         }))(obj)).Diggable
16331                         if x {
16332                                 write8(w, 1)
16333                         } else {
16334                                 write8(w, 0)
16335                         }
16336                 }
16337                 {
16338                         x := (*(*(struct {
16339                                 Param0 Content
16340
16341                                 Name   string
16342                                 Groups []Group
16343
16344                                 P1Type   Param1Type
16345                                 P2Type   Param2Type
16346                                 DrawType DrawType
16347
16348                                 Mesh  string
16349                                 Scale float32
16350                                 //mt:const uint8(6)
16351                                 Tiles        [6]TileDef
16352                                 OverlayTiles [6]TileDef
16353                                 //mt:const uint8(6)
16354                                 SpecialTiles [6]TileDef
16355
16356                                 Color   color.NRGBA
16357                                 Palette Texture
16358
16359                                 Waving       WaveType
16360                                 ConnectSides uint8
16361                                 ConnectTo    []Content
16362                                 InsideTint   color.NRGBA
16363                                 Level        uint8 // Must be < 128.
16364
16365                                 Translucent bool // Sunlight is scattered and becomes normal light.
16366                                 Transparent bool // Sunlight isn't scattered.
16367                                 LightSrc    uint8
16368
16369                                 GndContent   bool
16370                                 Collides     bool
16371                                 Pointable    bool
16372                                 Diggable     bool
16373                                 Climbable    bool
16374                                 Replaceable  bool
16375                                 OnRightClick bool
16376
16377                                 DmgPerSec int32
16378
16379                                 LiquidType   LiquidType
16380                                 FlowingAlt   string
16381                                 SrcAlt       string
16382                                 Viscosity    uint8 // 0-7
16383                                 LiqRenewable bool
16384                                 FlowRange    uint8
16385                                 DrownDmg     uint8
16386                                 Floodable    bool
16387
16388                                 DrawBox, ColBox, SelBox NodeBox
16389
16390                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16391
16392                                 LegacyFaceDir bool
16393                                 LegacyMounted bool
16394
16395                                 DigPredict string
16396
16397                                 MaxLvl uint8
16398
16399                                 AlphaUse
16400                         }))(obj)).Climbable
16401                         if x {
16402                                 write8(w, 1)
16403                         } else {
16404                                 write8(w, 0)
16405                         }
16406                 }
16407                 {
16408                         x := (*(*(struct {
16409                                 Param0 Content
16410
16411                                 Name   string
16412                                 Groups []Group
16413
16414                                 P1Type   Param1Type
16415                                 P2Type   Param2Type
16416                                 DrawType DrawType
16417
16418                                 Mesh  string
16419                                 Scale float32
16420                                 //mt:const uint8(6)
16421                                 Tiles        [6]TileDef
16422                                 OverlayTiles [6]TileDef
16423                                 //mt:const uint8(6)
16424                                 SpecialTiles [6]TileDef
16425
16426                                 Color   color.NRGBA
16427                                 Palette Texture
16428
16429                                 Waving       WaveType
16430                                 ConnectSides uint8
16431                                 ConnectTo    []Content
16432                                 InsideTint   color.NRGBA
16433                                 Level        uint8 // Must be < 128.
16434
16435                                 Translucent bool // Sunlight is scattered and becomes normal light.
16436                                 Transparent bool // Sunlight isn't scattered.
16437                                 LightSrc    uint8
16438
16439                                 GndContent   bool
16440                                 Collides     bool
16441                                 Pointable    bool
16442                                 Diggable     bool
16443                                 Climbable    bool
16444                                 Replaceable  bool
16445                                 OnRightClick bool
16446
16447                                 DmgPerSec int32
16448
16449                                 LiquidType   LiquidType
16450                                 FlowingAlt   string
16451                                 SrcAlt       string
16452                                 Viscosity    uint8 // 0-7
16453                                 LiqRenewable bool
16454                                 FlowRange    uint8
16455                                 DrownDmg     uint8
16456                                 Floodable    bool
16457
16458                                 DrawBox, ColBox, SelBox NodeBox
16459
16460                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16461
16462                                 LegacyFaceDir bool
16463                                 LegacyMounted bool
16464
16465                                 DigPredict string
16466
16467                                 MaxLvl uint8
16468
16469                                 AlphaUse
16470                         }))(obj)).Replaceable
16471                         if x {
16472                                 write8(w, 1)
16473                         } else {
16474                                 write8(w, 0)
16475                         }
16476                 }
16477                 {
16478                         x := (*(*(struct {
16479                                 Param0 Content
16480
16481                                 Name   string
16482                                 Groups []Group
16483
16484                                 P1Type   Param1Type
16485                                 P2Type   Param2Type
16486                                 DrawType DrawType
16487
16488                                 Mesh  string
16489                                 Scale float32
16490                                 //mt:const uint8(6)
16491                                 Tiles        [6]TileDef
16492                                 OverlayTiles [6]TileDef
16493                                 //mt:const uint8(6)
16494                                 SpecialTiles [6]TileDef
16495
16496                                 Color   color.NRGBA
16497                                 Palette Texture
16498
16499                                 Waving       WaveType
16500                                 ConnectSides uint8
16501                                 ConnectTo    []Content
16502                                 InsideTint   color.NRGBA
16503                                 Level        uint8 // Must be < 128.
16504
16505                                 Translucent bool // Sunlight is scattered and becomes normal light.
16506                                 Transparent bool // Sunlight isn't scattered.
16507                                 LightSrc    uint8
16508
16509                                 GndContent   bool
16510                                 Collides     bool
16511                                 Pointable    bool
16512                                 Diggable     bool
16513                                 Climbable    bool
16514                                 Replaceable  bool
16515                                 OnRightClick bool
16516
16517                                 DmgPerSec int32
16518
16519                                 LiquidType   LiquidType
16520                                 FlowingAlt   string
16521                                 SrcAlt       string
16522                                 Viscosity    uint8 // 0-7
16523                                 LiqRenewable bool
16524                                 FlowRange    uint8
16525                                 DrownDmg     uint8
16526                                 Floodable    bool
16527
16528                                 DrawBox, ColBox, SelBox NodeBox
16529
16530                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16531
16532                                 LegacyFaceDir bool
16533                                 LegacyMounted bool
16534
16535                                 DigPredict string
16536
16537                                 MaxLvl uint8
16538
16539                                 AlphaUse
16540                         }))(obj)).OnRightClick
16541                         if x {
16542                                 write8(w, 1)
16543                         } else {
16544                                 write8(w, 0)
16545                         }
16546                 }
16547                 {
16548                         x := (*(*(struct {
16549                                 Param0 Content
16550
16551                                 Name   string
16552                                 Groups []Group
16553
16554                                 P1Type   Param1Type
16555                                 P2Type   Param2Type
16556                                 DrawType DrawType
16557
16558                                 Mesh  string
16559                                 Scale float32
16560                                 //mt:const uint8(6)
16561                                 Tiles        [6]TileDef
16562                                 OverlayTiles [6]TileDef
16563                                 //mt:const uint8(6)
16564                                 SpecialTiles [6]TileDef
16565
16566                                 Color   color.NRGBA
16567                                 Palette Texture
16568
16569                                 Waving       WaveType
16570                                 ConnectSides uint8
16571                                 ConnectTo    []Content
16572                                 InsideTint   color.NRGBA
16573                                 Level        uint8 // Must be < 128.
16574
16575                                 Translucent bool // Sunlight is scattered and becomes normal light.
16576                                 Transparent bool // Sunlight isn't scattered.
16577                                 LightSrc    uint8
16578
16579                                 GndContent   bool
16580                                 Collides     bool
16581                                 Pointable    bool
16582                                 Diggable     bool
16583                                 Climbable    bool
16584                                 Replaceable  bool
16585                                 OnRightClick bool
16586
16587                                 DmgPerSec int32
16588
16589                                 LiquidType   LiquidType
16590                                 FlowingAlt   string
16591                                 SrcAlt       string
16592                                 Viscosity    uint8 // 0-7
16593                                 LiqRenewable bool
16594                                 FlowRange    uint8
16595                                 DrownDmg     uint8
16596                                 Floodable    bool
16597
16598                                 DrawBox, ColBox, SelBox NodeBox
16599
16600                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16601
16602                                 LegacyFaceDir bool
16603                                 LegacyMounted bool
16604
16605                                 DigPredict string
16606
16607                                 MaxLvl uint8
16608
16609                                 AlphaUse
16610                         }))(obj)).DmgPerSec
16611                         write32(w, uint32(x))
16612                 }
16613                 if err := pcall(func() {
16614                         ((*(*(struct {
16615                                 Param0 Content
16616
16617                                 Name   string
16618                                 Groups []Group
16619
16620                                 P1Type   Param1Type
16621                                 P2Type   Param2Type
16622                                 DrawType DrawType
16623
16624                                 Mesh  string
16625                                 Scale float32
16626                                 //mt:const uint8(6)
16627                                 Tiles        [6]TileDef
16628                                 OverlayTiles [6]TileDef
16629                                 //mt:const uint8(6)
16630                                 SpecialTiles [6]TileDef
16631
16632                                 Color   color.NRGBA
16633                                 Palette Texture
16634
16635                                 Waving       WaveType
16636                                 ConnectSides uint8
16637                                 ConnectTo    []Content
16638                                 InsideTint   color.NRGBA
16639                                 Level        uint8 // Must be < 128.
16640
16641                                 Translucent bool // Sunlight is scattered and becomes normal light.
16642                                 Transparent bool // Sunlight isn't scattered.
16643                                 LightSrc    uint8
16644
16645                                 GndContent   bool
16646                                 Collides     bool
16647                                 Pointable    bool
16648                                 Diggable     bool
16649                                 Climbable    bool
16650                                 Replaceable  bool
16651                                 OnRightClick bool
16652
16653                                 DmgPerSec int32
16654
16655                                 LiquidType   LiquidType
16656                                 FlowingAlt   string
16657                                 SrcAlt       string
16658                                 Viscosity    uint8 // 0-7
16659                                 LiqRenewable bool
16660                                 FlowRange    uint8
16661                                 DrownDmg     uint8
16662                                 Floodable    bool
16663
16664                                 DrawBox, ColBox, SelBox NodeBox
16665
16666                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16667
16668                                 LegacyFaceDir bool
16669                                 LegacyMounted bool
16670
16671                                 DigPredict string
16672
16673                                 MaxLvl uint8
16674
16675                                 AlphaUse
16676                         }))(obj)).LiquidType).serialize(w)
16677                 }); err != nil {
16678                         if err == io.EOF {
16679                                 chk(io.EOF)
16680                         }
16681                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LiquidType", err))
16682                 }
16683                 if len(([]byte((*(*(struct {
16684                         Param0 Content
16685
16686                         Name   string
16687                         Groups []Group
16688
16689                         P1Type   Param1Type
16690                         P2Type   Param2Type
16691                         DrawType DrawType
16692
16693                         Mesh  string
16694                         Scale float32
16695                         //mt:const uint8(6)
16696                         Tiles        [6]TileDef
16697                         OverlayTiles [6]TileDef
16698                         //mt:const uint8(6)
16699                         SpecialTiles [6]TileDef
16700
16701                         Color   color.NRGBA
16702                         Palette Texture
16703
16704                         Waving       WaveType
16705                         ConnectSides uint8
16706                         ConnectTo    []Content
16707                         InsideTint   color.NRGBA
16708                         Level        uint8 // Must be < 128.
16709
16710                         Translucent bool // Sunlight is scattered and becomes normal light.
16711                         Transparent bool // Sunlight isn't scattered.
16712                         LightSrc    uint8
16713
16714                         GndContent   bool
16715                         Collides     bool
16716                         Pointable    bool
16717                         Diggable     bool
16718                         Climbable    bool
16719                         Replaceable  bool
16720                         OnRightClick bool
16721
16722                         DmgPerSec int32
16723
16724                         LiquidType   LiquidType
16725                         FlowingAlt   string
16726                         SrcAlt       string
16727                         Viscosity    uint8 // 0-7
16728                         LiqRenewable bool
16729                         FlowRange    uint8
16730                         DrownDmg     uint8
16731                         Floodable    bool
16732
16733                         DrawBox, ColBox, SelBox NodeBox
16734
16735                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16736
16737                         LegacyFaceDir bool
16738                         LegacyMounted bool
16739
16740                         DigPredict string
16741
16742                         MaxLvl uint8
16743
16744                         AlphaUse
16745                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
16746                         chk(ErrTooLong)
16747                 }
16748                 {
16749                         x := uint16(len(([]byte((*(*(struct {
16750                                 Param0 Content
16751
16752                                 Name   string
16753                                 Groups []Group
16754
16755                                 P1Type   Param1Type
16756                                 P2Type   Param2Type
16757                                 DrawType DrawType
16758
16759                                 Mesh  string
16760                                 Scale float32
16761                                 //mt:const uint8(6)
16762                                 Tiles        [6]TileDef
16763                                 OverlayTiles [6]TileDef
16764                                 //mt:const uint8(6)
16765                                 SpecialTiles [6]TileDef
16766
16767                                 Color   color.NRGBA
16768                                 Palette Texture
16769
16770                                 Waving       WaveType
16771                                 ConnectSides uint8
16772                                 ConnectTo    []Content
16773                                 InsideTint   color.NRGBA
16774                                 Level        uint8 // Must be < 128.
16775
16776                                 Translucent bool // Sunlight is scattered and becomes normal light.
16777                                 Transparent bool // Sunlight isn't scattered.
16778                                 LightSrc    uint8
16779
16780                                 GndContent   bool
16781                                 Collides     bool
16782                                 Pointable    bool
16783                                 Diggable     bool
16784                                 Climbable    bool
16785                                 Replaceable  bool
16786                                 OnRightClick bool
16787
16788                                 DmgPerSec int32
16789
16790                                 LiquidType   LiquidType
16791                                 FlowingAlt   string
16792                                 SrcAlt       string
16793                                 Viscosity    uint8 // 0-7
16794                                 LiqRenewable bool
16795                                 FlowRange    uint8
16796                                 DrownDmg     uint8
16797                                 Floodable    bool
16798
16799                                 DrawBox, ColBox, SelBox NodeBox
16800
16801                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16802
16803                                 LegacyFaceDir bool
16804                                 LegacyMounted bool
16805
16806                                 DigPredict string
16807
16808                                 MaxLvl uint8
16809
16810                                 AlphaUse
16811                         }))(obj)).FlowingAlt))))
16812                         write16(w, uint16(x))
16813                 }
16814                 {
16815                         _, err := w.Write(([]byte((*(*(struct {
16816                                 Param0 Content
16817
16818                                 Name   string
16819                                 Groups []Group
16820
16821                                 P1Type   Param1Type
16822                                 P2Type   Param2Type
16823                                 DrawType DrawType
16824
16825                                 Mesh  string
16826                                 Scale float32
16827                                 //mt:const uint8(6)
16828                                 Tiles        [6]TileDef
16829                                 OverlayTiles [6]TileDef
16830                                 //mt:const uint8(6)
16831                                 SpecialTiles [6]TileDef
16832
16833                                 Color   color.NRGBA
16834                                 Palette Texture
16835
16836                                 Waving       WaveType
16837                                 ConnectSides uint8
16838                                 ConnectTo    []Content
16839                                 InsideTint   color.NRGBA
16840                                 Level        uint8 // Must be < 128.
16841
16842                                 Translucent bool // Sunlight is scattered and becomes normal light.
16843                                 Transparent bool // Sunlight isn't scattered.
16844                                 LightSrc    uint8
16845
16846                                 GndContent   bool
16847                                 Collides     bool
16848                                 Pointable    bool
16849                                 Diggable     bool
16850                                 Climbable    bool
16851                                 Replaceable  bool
16852                                 OnRightClick bool
16853
16854                                 DmgPerSec int32
16855
16856                                 LiquidType   LiquidType
16857                                 FlowingAlt   string
16858                                 SrcAlt       string
16859                                 Viscosity    uint8 // 0-7
16860                                 LiqRenewable bool
16861                                 FlowRange    uint8
16862                                 DrownDmg     uint8
16863                                 Floodable    bool
16864
16865                                 DrawBox, ColBox, SelBox NodeBox
16866
16867                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16868
16869                                 LegacyFaceDir bool
16870                                 LegacyMounted bool
16871
16872                                 DigPredict string
16873
16874                                 MaxLvl uint8
16875
16876                                 AlphaUse
16877                         }))(obj)).FlowingAlt))[:])
16878                         chk(err)
16879                 }
16880                 if len(([]byte((*(*(struct {
16881                         Param0 Content
16882
16883                         Name   string
16884                         Groups []Group
16885
16886                         P1Type   Param1Type
16887                         P2Type   Param2Type
16888                         DrawType DrawType
16889
16890                         Mesh  string
16891                         Scale float32
16892                         //mt:const uint8(6)
16893                         Tiles        [6]TileDef
16894                         OverlayTiles [6]TileDef
16895                         //mt:const uint8(6)
16896                         SpecialTiles [6]TileDef
16897
16898                         Color   color.NRGBA
16899                         Palette Texture
16900
16901                         Waving       WaveType
16902                         ConnectSides uint8
16903                         ConnectTo    []Content
16904                         InsideTint   color.NRGBA
16905                         Level        uint8 // Must be < 128.
16906
16907                         Translucent bool // Sunlight is scattered and becomes normal light.
16908                         Transparent bool // Sunlight isn't scattered.
16909                         LightSrc    uint8
16910
16911                         GndContent   bool
16912                         Collides     bool
16913                         Pointable    bool
16914                         Diggable     bool
16915                         Climbable    bool
16916                         Replaceable  bool
16917                         OnRightClick bool
16918
16919                         DmgPerSec int32
16920
16921                         LiquidType   LiquidType
16922                         FlowingAlt   string
16923                         SrcAlt       string
16924                         Viscosity    uint8 // 0-7
16925                         LiqRenewable bool
16926                         FlowRange    uint8
16927                         DrownDmg     uint8
16928                         Floodable    bool
16929
16930                         DrawBox, ColBox, SelBox NodeBox
16931
16932                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16933
16934                         LegacyFaceDir bool
16935                         LegacyMounted bool
16936
16937                         DigPredict string
16938
16939                         MaxLvl uint8
16940
16941                         AlphaUse
16942                 }))(obj)).SrcAlt))) > math.MaxUint16 {
16943                         chk(ErrTooLong)
16944                 }
16945                 {
16946                         x := uint16(len(([]byte((*(*(struct {
16947                                 Param0 Content
16948
16949                                 Name   string
16950                                 Groups []Group
16951
16952                                 P1Type   Param1Type
16953                                 P2Type   Param2Type
16954                                 DrawType DrawType
16955
16956                                 Mesh  string
16957                                 Scale float32
16958                                 //mt:const uint8(6)
16959                                 Tiles        [6]TileDef
16960                                 OverlayTiles [6]TileDef
16961                                 //mt:const uint8(6)
16962                                 SpecialTiles [6]TileDef
16963
16964                                 Color   color.NRGBA
16965                                 Palette Texture
16966
16967                                 Waving       WaveType
16968                                 ConnectSides uint8
16969                                 ConnectTo    []Content
16970                                 InsideTint   color.NRGBA
16971                                 Level        uint8 // Must be < 128.
16972
16973                                 Translucent bool // Sunlight is scattered and becomes normal light.
16974                                 Transparent bool // Sunlight isn't scattered.
16975                                 LightSrc    uint8
16976
16977                                 GndContent   bool
16978                                 Collides     bool
16979                                 Pointable    bool
16980                                 Diggable     bool
16981                                 Climbable    bool
16982                                 Replaceable  bool
16983                                 OnRightClick bool
16984
16985                                 DmgPerSec int32
16986
16987                                 LiquidType   LiquidType
16988                                 FlowingAlt   string
16989                                 SrcAlt       string
16990                                 Viscosity    uint8 // 0-7
16991                                 LiqRenewable bool
16992                                 FlowRange    uint8
16993                                 DrownDmg     uint8
16994                                 Floodable    bool
16995
16996                                 DrawBox, ColBox, SelBox NodeBox
16997
16998                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16999
17000                                 LegacyFaceDir bool
17001                                 LegacyMounted bool
17002
17003                                 DigPredict string
17004
17005                                 MaxLvl uint8
17006
17007                                 AlphaUse
17008                         }))(obj)).SrcAlt))))
17009                         write16(w, uint16(x))
17010                 }
17011                 {
17012                         _, err := w.Write(([]byte((*(*(struct {
17013                                 Param0 Content
17014
17015                                 Name   string
17016                                 Groups []Group
17017
17018                                 P1Type   Param1Type
17019                                 P2Type   Param2Type
17020                                 DrawType DrawType
17021
17022                                 Mesh  string
17023                                 Scale float32
17024                                 //mt:const uint8(6)
17025                                 Tiles        [6]TileDef
17026                                 OverlayTiles [6]TileDef
17027                                 //mt:const uint8(6)
17028                                 SpecialTiles [6]TileDef
17029
17030                                 Color   color.NRGBA
17031                                 Palette Texture
17032
17033                                 Waving       WaveType
17034                                 ConnectSides uint8
17035                                 ConnectTo    []Content
17036                                 InsideTint   color.NRGBA
17037                                 Level        uint8 // Must be < 128.
17038
17039                                 Translucent bool // Sunlight is scattered and becomes normal light.
17040                                 Transparent bool // Sunlight isn't scattered.
17041                                 LightSrc    uint8
17042
17043                                 GndContent   bool
17044                                 Collides     bool
17045                                 Pointable    bool
17046                                 Diggable     bool
17047                                 Climbable    bool
17048                                 Replaceable  bool
17049                                 OnRightClick bool
17050
17051                                 DmgPerSec int32
17052
17053                                 LiquidType   LiquidType
17054                                 FlowingAlt   string
17055                                 SrcAlt       string
17056                                 Viscosity    uint8 // 0-7
17057                                 LiqRenewable bool
17058                                 FlowRange    uint8
17059                                 DrownDmg     uint8
17060                                 Floodable    bool
17061
17062                                 DrawBox, ColBox, SelBox NodeBox
17063
17064                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17065
17066                                 LegacyFaceDir bool
17067                                 LegacyMounted bool
17068
17069                                 DigPredict string
17070
17071                                 MaxLvl uint8
17072
17073                                 AlphaUse
17074                         }))(obj)).SrcAlt))[:])
17075                         chk(err)
17076                 }
17077                 {
17078                         x := (*(*(struct {
17079                                 Param0 Content
17080
17081                                 Name   string
17082                                 Groups []Group
17083
17084                                 P1Type   Param1Type
17085                                 P2Type   Param2Type
17086                                 DrawType DrawType
17087
17088                                 Mesh  string
17089                                 Scale float32
17090                                 //mt:const uint8(6)
17091                                 Tiles        [6]TileDef
17092                                 OverlayTiles [6]TileDef
17093                                 //mt:const uint8(6)
17094                                 SpecialTiles [6]TileDef
17095
17096                                 Color   color.NRGBA
17097                                 Palette Texture
17098
17099                                 Waving       WaveType
17100                                 ConnectSides uint8
17101                                 ConnectTo    []Content
17102                                 InsideTint   color.NRGBA
17103                                 Level        uint8 // Must be < 128.
17104
17105                                 Translucent bool // Sunlight is scattered and becomes normal light.
17106                                 Transparent bool // Sunlight isn't scattered.
17107                                 LightSrc    uint8
17108
17109                                 GndContent   bool
17110                                 Collides     bool
17111                                 Pointable    bool
17112                                 Diggable     bool
17113                                 Climbable    bool
17114                                 Replaceable  bool
17115                                 OnRightClick bool
17116
17117                                 DmgPerSec int32
17118
17119                                 LiquidType   LiquidType
17120                                 FlowingAlt   string
17121                                 SrcAlt       string
17122                                 Viscosity    uint8 // 0-7
17123                                 LiqRenewable bool
17124                                 FlowRange    uint8
17125                                 DrownDmg     uint8
17126                                 Floodable    bool
17127
17128                                 DrawBox, ColBox, SelBox NodeBox
17129
17130                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17131
17132                                 LegacyFaceDir bool
17133                                 LegacyMounted bool
17134
17135                                 DigPredict string
17136
17137                                 MaxLvl uint8
17138
17139                                 AlphaUse
17140                         }))(obj)).Viscosity
17141                         write8(w, uint8(x))
17142                 }
17143                 {
17144                         x := (*(*(struct {
17145                                 Param0 Content
17146
17147                                 Name   string
17148                                 Groups []Group
17149
17150                                 P1Type   Param1Type
17151                                 P2Type   Param2Type
17152                                 DrawType DrawType
17153
17154                                 Mesh  string
17155                                 Scale float32
17156                                 //mt:const uint8(6)
17157                                 Tiles        [6]TileDef
17158                                 OverlayTiles [6]TileDef
17159                                 //mt:const uint8(6)
17160                                 SpecialTiles [6]TileDef
17161
17162                                 Color   color.NRGBA
17163                                 Palette Texture
17164
17165                                 Waving       WaveType
17166                                 ConnectSides uint8
17167                                 ConnectTo    []Content
17168                                 InsideTint   color.NRGBA
17169                                 Level        uint8 // Must be < 128.
17170
17171                                 Translucent bool // Sunlight is scattered and becomes normal light.
17172                                 Transparent bool // Sunlight isn't scattered.
17173                                 LightSrc    uint8
17174
17175                                 GndContent   bool
17176                                 Collides     bool
17177                                 Pointable    bool
17178                                 Diggable     bool
17179                                 Climbable    bool
17180                                 Replaceable  bool
17181                                 OnRightClick bool
17182
17183                                 DmgPerSec int32
17184
17185                                 LiquidType   LiquidType
17186                                 FlowingAlt   string
17187                                 SrcAlt       string
17188                                 Viscosity    uint8 // 0-7
17189                                 LiqRenewable bool
17190                                 FlowRange    uint8
17191                                 DrownDmg     uint8
17192                                 Floodable    bool
17193
17194                                 DrawBox, ColBox, SelBox NodeBox
17195
17196                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17197
17198                                 LegacyFaceDir bool
17199                                 LegacyMounted bool
17200
17201                                 DigPredict string
17202
17203                                 MaxLvl uint8
17204
17205                                 AlphaUse
17206                         }))(obj)).LiqRenewable
17207                         if x {
17208                                 write8(w, 1)
17209                         } else {
17210                                 write8(w, 0)
17211                         }
17212                 }
17213                 {
17214                         x := (*(*(struct {
17215                                 Param0 Content
17216
17217                                 Name   string
17218                                 Groups []Group
17219
17220                                 P1Type   Param1Type
17221                                 P2Type   Param2Type
17222                                 DrawType DrawType
17223
17224                                 Mesh  string
17225                                 Scale float32
17226                                 //mt:const uint8(6)
17227                                 Tiles        [6]TileDef
17228                                 OverlayTiles [6]TileDef
17229                                 //mt:const uint8(6)
17230                                 SpecialTiles [6]TileDef
17231
17232                                 Color   color.NRGBA
17233                                 Palette Texture
17234
17235                                 Waving       WaveType
17236                                 ConnectSides uint8
17237                                 ConnectTo    []Content
17238                                 InsideTint   color.NRGBA
17239                                 Level        uint8 // Must be < 128.
17240
17241                                 Translucent bool // Sunlight is scattered and becomes normal light.
17242                                 Transparent bool // Sunlight isn't scattered.
17243                                 LightSrc    uint8
17244
17245                                 GndContent   bool
17246                                 Collides     bool
17247                                 Pointable    bool
17248                                 Diggable     bool
17249                                 Climbable    bool
17250                                 Replaceable  bool
17251                                 OnRightClick bool
17252
17253                                 DmgPerSec int32
17254
17255                                 LiquidType   LiquidType
17256                                 FlowingAlt   string
17257                                 SrcAlt       string
17258                                 Viscosity    uint8 // 0-7
17259                                 LiqRenewable bool
17260                                 FlowRange    uint8
17261                                 DrownDmg     uint8
17262                                 Floodable    bool
17263
17264                                 DrawBox, ColBox, SelBox NodeBox
17265
17266                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17267
17268                                 LegacyFaceDir bool
17269                                 LegacyMounted bool
17270
17271                                 DigPredict string
17272
17273                                 MaxLvl uint8
17274
17275                                 AlphaUse
17276                         }))(obj)).FlowRange
17277                         write8(w, uint8(x))
17278                 }
17279                 {
17280                         x := (*(*(struct {
17281                                 Param0 Content
17282
17283                                 Name   string
17284                                 Groups []Group
17285
17286                                 P1Type   Param1Type
17287                                 P2Type   Param2Type
17288                                 DrawType DrawType
17289
17290                                 Mesh  string
17291                                 Scale float32
17292                                 //mt:const uint8(6)
17293                                 Tiles        [6]TileDef
17294                                 OverlayTiles [6]TileDef
17295                                 //mt:const uint8(6)
17296                                 SpecialTiles [6]TileDef
17297
17298                                 Color   color.NRGBA
17299                                 Palette Texture
17300
17301                                 Waving       WaveType
17302                                 ConnectSides uint8
17303                                 ConnectTo    []Content
17304                                 InsideTint   color.NRGBA
17305                                 Level        uint8 // Must be < 128.
17306
17307                                 Translucent bool // Sunlight is scattered and becomes normal light.
17308                                 Transparent bool // Sunlight isn't scattered.
17309                                 LightSrc    uint8
17310
17311                                 GndContent   bool
17312                                 Collides     bool
17313                                 Pointable    bool
17314                                 Diggable     bool
17315                                 Climbable    bool
17316                                 Replaceable  bool
17317                                 OnRightClick bool
17318
17319                                 DmgPerSec int32
17320
17321                                 LiquidType   LiquidType
17322                                 FlowingAlt   string
17323                                 SrcAlt       string
17324                                 Viscosity    uint8 // 0-7
17325                                 LiqRenewable bool
17326                                 FlowRange    uint8
17327                                 DrownDmg     uint8
17328                                 Floodable    bool
17329
17330                                 DrawBox, ColBox, SelBox NodeBox
17331
17332                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17333
17334                                 LegacyFaceDir bool
17335                                 LegacyMounted bool
17336
17337                                 DigPredict string
17338
17339                                 MaxLvl uint8
17340
17341                                 AlphaUse
17342                         }))(obj)).DrownDmg
17343                         write8(w, uint8(x))
17344                 }
17345                 {
17346                         x := (*(*(struct {
17347                                 Param0 Content
17348
17349                                 Name   string
17350                                 Groups []Group
17351
17352                                 P1Type   Param1Type
17353                                 P2Type   Param2Type
17354                                 DrawType DrawType
17355
17356                                 Mesh  string
17357                                 Scale float32
17358                                 //mt:const uint8(6)
17359                                 Tiles        [6]TileDef
17360                                 OverlayTiles [6]TileDef
17361                                 //mt:const uint8(6)
17362                                 SpecialTiles [6]TileDef
17363
17364                                 Color   color.NRGBA
17365                                 Palette Texture
17366
17367                                 Waving       WaveType
17368                                 ConnectSides uint8
17369                                 ConnectTo    []Content
17370                                 InsideTint   color.NRGBA
17371                                 Level        uint8 // Must be < 128.
17372
17373                                 Translucent bool // Sunlight is scattered and becomes normal light.
17374                                 Transparent bool // Sunlight isn't scattered.
17375                                 LightSrc    uint8
17376
17377                                 GndContent   bool
17378                                 Collides     bool
17379                                 Pointable    bool
17380                                 Diggable     bool
17381                                 Climbable    bool
17382                                 Replaceable  bool
17383                                 OnRightClick bool
17384
17385                                 DmgPerSec int32
17386
17387                                 LiquidType   LiquidType
17388                                 FlowingAlt   string
17389                                 SrcAlt       string
17390                                 Viscosity    uint8 // 0-7
17391                                 LiqRenewable bool
17392                                 FlowRange    uint8
17393                                 DrownDmg     uint8
17394                                 Floodable    bool
17395
17396                                 DrawBox, ColBox, SelBox NodeBox
17397
17398                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17399
17400                                 LegacyFaceDir bool
17401                                 LegacyMounted bool
17402
17403                                 DigPredict string
17404
17405                                 MaxLvl uint8
17406
17407                                 AlphaUse
17408                         }))(obj)).Floodable
17409                         if x {
17410                                 write8(w, 1)
17411                         } else {
17412                                 write8(w, 0)
17413                         }
17414                 }
17415                 if err := pcall(func() {
17416                         ((*(*(struct {
17417                                 Param0 Content
17418
17419                                 Name   string
17420                                 Groups []Group
17421
17422                                 P1Type   Param1Type
17423                                 P2Type   Param2Type
17424                                 DrawType DrawType
17425
17426                                 Mesh  string
17427                                 Scale float32
17428                                 //mt:const uint8(6)
17429                                 Tiles        [6]TileDef
17430                                 OverlayTiles [6]TileDef
17431                                 //mt:const uint8(6)
17432                                 SpecialTiles [6]TileDef
17433
17434                                 Color   color.NRGBA
17435                                 Palette Texture
17436
17437                                 Waving       WaveType
17438                                 ConnectSides uint8
17439                                 ConnectTo    []Content
17440                                 InsideTint   color.NRGBA
17441                                 Level        uint8 // Must be < 128.
17442
17443                                 Translucent bool // Sunlight is scattered and becomes normal light.
17444                                 Transparent bool // Sunlight isn't scattered.
17445                                 LightSrc    uint8
17446
17447                                 GndContent   bool
17448                                 Collides     bool
17449                                 Pointable    bool
17450                                 Diggable     bool
17451                                 Climbable    bool
17452                                 Replaceable  bool
17453                                 OnRightClick bool
17454
17455                                 DmgPerSec int32
17456
17457                                 LiquidType   LiquidType
17458                                 FlowingAlt   string
17459                                 SrcAlt       string
17460                                 Viscosity    uint8 // 0-7
17461                                 LiqRenewable bool
17462                                 FlowRange    uint8
17463                                 DrownDmg     uint8
17464                                 Floodable    bool
17465
17466                                 DrawBox, ColBox, SelBox NodeBox
17467
17468                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17469
17470                                 LegacyFaceDir bool
17471                                 LegacyMounted bool
17472
17473                                 DigPredict string
17474
17475                                 MaxLvl uint8
17476
17477                                 AlphaUse
17478                         }))(obj)).DrawBox).serialize(w)
17479                 }); err != nil {
17480                         if err == io.EOF {
17481                                 chk(io.EOF)
17482                         }
17483                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
17484                 }
17485                 if err := pcall(func() {
17486                         ((*(*(struct {
17487                                 Param0 Content
17488
17489                                 Name   string
17490                                 Groups []Group
17491
17492                                 P1Type   Param1Type
17493                                 P2Type   Param2Type
17494                                 DrawType DrawType
17495
17496                                 Mesh  string
17497                                 Scale float32
17498                                 //mt:const uint8(6)
17499                                 Tiles        [6]TileDef
17500                                 OverlayTiles [6]TileDef
17501                                 //mt:const uint8(6)
17502                                 SpecialTiles [6]TileDef
17503
17504                                 Color   color.NRGBA
17505                                 Palette Texture
17506
17507                                 Waving       WaveType
17508                                 ConnectSides uint8
17509                                 ConnectTo    []Content
17510                                 InsideTint   color.NRGBA
17511                                 Level        uint8 // Must be < 128.
17512
17513                                 Translucent bool // Sunlight is scattered and becomes normal light.
17514                                 Transparent bool // Sunlight isn't scattered.
17515                                 LightSrc    uint8
17516
17517                                 GndContent   bool
17518                                 Collides     bool
17519                                 Pointable    bool
17520                                 Diggable     bool
17521                                 Climbable    bool
17522                                 Replaceable  bool
17523                                 OnRightClick bool
17524
17525                                 DmgPerSec int32
17526
17527                                 LiquidType   LiquidType
17528                                 FlowingAlt   string
17529                                 SrcAlt       string
17530                                 Viscosity    uint8 // 0-7
17531                                 LiqRenewable bool
17532                                 FlowRange    uint8
17533                                 DrownDmg     uint8
17534                                 Floodable    bool
17535
17536                                 DrawBox, ColBox, SelBox NodeBox
17537
17538                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17539
17540                                 LegacyFaceDir bool
17541                                 LegacyMounted bool
17542
17543                                 DigPredict string
17544
17545                                 MaxLvl uint8
17546
17547                                 AlphaUse
17548                         }))(obj)).ColBox).serialize(w)
17549                 }); err != nil {
17550                         if err == io.EOF {
17551                                 chk(io.EOF)
17552                         }
17553                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
17554                 }
17555                 if err := pcall(func() {
17556                         ((*(*(struct {
17557                                 Param0 Content
17558
17559                                 Name   string
17560                                 Groups []Group
17561
17562                                 P1Type   Param1Type
17563                                 P2Type   Param2Type
17564                                 DrawType DrawType
17565
17566                                 Mesh  string
17567                                 Scale float32
17568                                 //mt:const uint8(6)
17569                                 Tiles        [6]TileDef
17570                                 OverlayTiles [6]TileDef
17571                                 //mt:const uint8(6)
17572                                 SpecialTiles [6]TileDef
17573
17574                                 Color   color.NRGBA
17575                                 Palette Texture
17576
17577                                 Waving       WaveType
17578                                 ConnectSides uint8
17579                                 ConnectTo    []Content
17580                                 InsideTint   color.NRGBA
17581                                 Level        uint8 // Must be < 128.
17582
17583                                 Translucent bool // Sunlight is scattered and becomes normal light.
17584                                 Transparent bool // Sunlight isn't scattered.
17585                                 LightSrc    uint8
17586
17587                                 GndContent   bool
17588                                 Collides     bool
17589                                 Pointable    bool
17590                                 Diggable     bool
17591                                 Climbable    bool
17592                                 Replaceable  bool
17593                                 OnRightClick bool
17594
17595                                 DmgPerSec int32
17596
17597                                 LiquidType   LiquidType
17598                                 FlowingAlt   string
17599                                 SrcAlt       string
17600                                 Viscosity    uint8 // 0-7
17601                                 LiqRenewable bool
17602                                 FlowRange    uint8
17603                                 DrownDmg     uint8
17604                                 Floodable    bool
17605
17606                                 DrawBox, ColBox, SelBox NodeBox
17607
17608                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17609
17610                                 LegacyFaceDir bool
17611                                 LegacyMounted bool
17612
17613                                 DigPredict string
17614
17615                                 MaxLvl uint8
17616
17617                                 AlphaUse
17618                         }))(obj)).SelBox).serialize(w)
17619                 }); err != nil {
17620                         if err == io.EOF {
17621                                 chk(io.EOF)
17622                         }
17623                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
17624                 }
17625                 if err := pcall(func() {
17626                         ((*(*(struct {
17627                                 Param0 Content
17628
17629                                 Name   string
17630                                 Groups []Group
17631
17632                                 P1Type   Param1Type
17633                                 P2Type   Param2Type
17634                                 DrawType DrawType
17635
17636                                 Mesh  string
17637                                 Scale float32
17638                                 //mt:const uint8(6)
17639                                 Tiles        [6]TileDef
17640                                 OverlayTiles [6]TileDef
17641                                 //mt:const uint8(6)
17642                                 SpecialTiles [6]TileDef
17643
17644                                 Color   color.NRGBA
17645                                 Palette Texture
17646
17647                                 Waving       WaveType
17648                                 ConnectSides uint8
17649                                 ConnectTo    []Content
17650                                 InsideTint   color.NRGBA
17651                                 Level        uint8 // Must be < 128.
17652
17653                                 Translucent bool // Sunlight is scattered and becomes normal light.
17654                                 Transparent bool // Sunlight isn't scattered.
17655                                 LightSrc    uint8
17656
17657                                 GndContent   bool
17658                                 Collides     bool
17659                                 Pointable    bool
17660                                 Diggable     bool
17661                                 Climbable    bool
17662                                 Replaceable  bool
17663                                 OnRightClick bool
17664
17665                                 DmgPerSec int32
17666
17667                                 LiquidType   LiquidType
17668                                 FlowingAlt   string
17669                                 SrcAlt       string
17670                                 Viscosity    uint8 // 0-7
17671                                 LiqRenewable bool
17672                                 FlowRange    uint8
17673                                 DrownDmg     uint8
17674                                 Floodable    bool
17675
17676                                 DrawBox, ColBox, SelBox NodeBox
17677
17678                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17679
17680                                 LegacyFaceDir bool
17681                                 LegacyMounted bool
17682
17683                                 DigPredict string
17684
17685                                 MaxLvl uint8
17686
17687                                 AlphaUse
17688                         }))(obj)).FootstepSnd).serialize(w)
17689                 }); err != nil {
17690                         if err == io.EOF {
17691                                 chk(io.EOF)
17692                         }
17693                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
17694                 }
17695                 if err := pcall(func() {
17696                         ((*(*(struct {
17697                                 Param0 Content
17698
17699                                 Name   string
17700                                 Groups []Group
17701
17702                                 P1Type   Param1Type
17703                                 P2Type   Param2Type
17704                                 DrawType DrawType
17705
17706                                 Mesh  string
17707                                 Scale float32
17708                                 //mt:const uint8(6)
17709                                 Tiles        [6]TileDef
17710                                 OverlayTiles [6]TileDef
17711                                 //mt:const uint8(6)
17712                                 SpecialTiles [6]TileDef
17713
17714                                 Color   color.NRGBA
17715                                 Palette Texture
17716
17717                                 Waving       WaveType
17718                                 ConnectSides uint8
17719                                 ConnectTo    []Content
17720                                 InsideTint   color.NRGBA
17721                                 Level        uint8 // Must be < 128.
17722
17723                                 Translucent bool // Sunlight is scattered and becomes normal light.
17724                                 Transparent bool // Sunlight isn't scattered.
17725                                 LightSrc    uint8
17726
17727                                 GndContent   bool
17728                                 Collides     bool
17729                                 Pointable    bool
17730                                 Diggable     bool
17731                                 Climbable    bool
17732                                 Replaceable  bool
17733                                 OnRightClick bool
17734
17735                                 DmgPerSec int32
17736
17737                                 LiquidType   LiquidType
17738                                 FlowingAlt   string
17739                                 SrcAlt       string
17740                                 Viscosity    uint8 // 0-7
17741                                 LiqRenewable bool
17742                                 FlowRange    uint8
17743                                 DrownDmg     uint8
17744                                 Floodable    bool
17745
17746                                 DrawBox, ColBox, SelBox NodeBox
17747
17748                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17749
17750                                 LegacyFaceDir bool
17751                                 LegacyMounted bool
17752
17753                                 DigPredict string
17754
17755                                 MaxLvl uint8
17756
17757                                 AlphaUse
17758                         }))(obj)).DiggingSnd).serialize(w)
17759                 }); err != nil {
17760                         if err == io.EOF {
17761                                 chk(io.EOF)
17762                         }
17763                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
17764                 }
17765                 if err := pcall(func() {
17766                         ((*(*(struct {
17767                                 Param0 Content
17768
17769                                 Name   string
17770                                 Groups []Group
17771
17772                                 P1Type   Param1Type
17773                                 P2Type   Param2Type
17774                                 DrawType DrawType
17775
17776                                 Mesh  string
17777                                 Scale float32
17778                                 //mt:const uint8(6)
17779                                 Tiles        [6]TileDef
17780                                 OverlayTiles [6]TileDef
17781                                 //mt:const uint8(6)
17782                                 SpecialTiles [6]TileDef
17783
17784                                 Color   color.NRGBA
17785                                 Palette Texture
17786
17787                                 Waving       WaveType
17788                                 ConnectSides uint8
17789                                 ConnectTo    []Content
17790                                 InsideTint   color.NRGBA
17791                                 Level        uint8 // Must be < 128.
17792
17793                                 Translucent bool // Sunlight is scattered and becomes normal light.
17794                                 Transparent bool // Sunlight isn't scattered.
17795                                 LightSrc    uint8
17796
17797                                 GndContent   bool
17798                                 Collides     bool
17799                                 Pointable    bool
17800                                 Diggable     bool
17801                                 Climbable    bool
17802                                 Replaceable  bool
17803                                 OnRightClick bool
17804
17805                                 DmgPerSec int32
17806
17807                                 LiquidType   LiquidType
17808                                 FlowingAlt   string
17809                                 SrcAlt       string
17810                                 Viscosity    uint8 // 0-7
17811                                 LiqRenewable bool
17812                                 FlowRange    uint8
17813                                 DrownDmg     uint8
17814                                 Floodable    bool
17815
17816                                 DrawBox, ColBox, SelBox NodeBox
17817
17818                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17819
17820                                 LegacyFaceDir bool
17821                                 LegacyMounted bool
17822
17823                                 DigPredict string
17824
17825                                 MaxLvl uint8
17826
17827                                 AlphaUse
17828                         }))(obj)).DugSnd).serialize(w)
17829                 }); err != nil {
17830                         if err == io.EOF {
17831                                 chk(io.EOF)
17832                         }
17833                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
17834                 }
17835                 {
17836                         x := (*(*(struct {
17837                                 Param0 Content
17838
17839                                 Name   string
17840                                 Groups []Group
17841
17842                                 P1Type   Param1Type
17843                                 P2Type   Param2Type
17844                                 DrawType DrawType
17845
17846                                 Mesh  string
17847                                 Scale float32
17848                                 //mt:const uint8(6)
17849                                 Tiles        [6]TileDef
17850                                 OverlayTiles [6]TileDef
17851                                 //mt:const uint8(6)
17852                                 SpecialTiles [6]TileDef
17853
17854                                 Color   color.NRGBA
17855                                 Palette Texture
17856
17857                                 Waving       WaveType
17858                                 ConnectSides uint8
17859                                 ConnectTo    []Content
17860                                 InsideTint   color.NRGBA
17861                                 Level        uint8 // Must be < 128.
17862
17863                                 Translucent bool // Sunlight is scattered and becomes normal light.
17864                                 Transparent bool // Sunlight isn't scattered.
17865                                 LightSrc    uint8
17866
17867                                 GndContent   bool
17868                                 Collides     bool
17869                                 Pointable    bool
17870                                 Diggable     bool
17871                                 Climbable    bool
17872                                 Replaceable  bool
17873                                 OnRightClick bool
17874
17875                                 DmgPerSec int32
17876
17877                                 LiquidType   LiquidType
17878                                 FlowingAlt   string
17879                                 SrcAlt       string
17880                                 Viscosity    uint8 // 0-7
17881                                 LiqRenewable bool
17882                                 FlowRange    uint8
17883                                 DrownDmg     uint8
17884                                 Floodable    bool
17885
17886                                 DrawBox, ColBox, SelBox NodeBox
17887
17888                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17889
17890                                 LegacyFaceDir bool
17891                                 LegacyMounted bool
17892
17893                                 DigPredict string
17894
17895                                 MaxLvl uint8
17896
17897                                 AlphaUse
17898                         }))(obj)).LegacyFaceDir
17899                         if x {
17900                                 write8(w, 1)
17901                         } else {
17902                                 write8(w, 0)
17903                         }
17904                 }
17905                 {
17906                         x := (*(*(struct {
17907                                 Param0 Content
17908
17909                                 Name   string
17910                                 Groups []Group
17911
17912                                 P1Type   Param1Type
17913                                 P2Type   Param2Type
17914                                 DrawType DrawType
17915
17916                                 Mesh  string
17917                                 Scale float32
17918                                 //mt:const uint8(6)
17919                                 Tiles        [6]TileDef
17920                                 OverlayTiles [6]TileDef
17921                                 //mt:const uint8(6)
17922                                 SpecialTiles [6]TileDef
17923
17924                                 Color   color.NRGBA
17925                                 Palette Texture
17926
17927                                 Waving       WaveType
17928                                 ConnectSides uint8
17929                                 ConnectTo    []Content
17930                                 InsideTint   color.NRGBA
17931                                 Level        uint8 // Must be < 128.
17932
17933                                 Translucent bool // Sunlight is scattered and becomes normal light.
17934                                 Transparent bool // Sunlight isn't scattered.
17935                                 LightSrc    uint8
17936
17937                                 GndContent   bool
17938                                 Collides     bool
17939                                 Pointable    bool
17940                                 Diggable     bool
17941                                 Climbable    bool
17942                                 Replaceable  bool
17943                                 OnRightClick bool
17944
17945                                 DmgPerSec int32
17946
17947                                 LiquidType   LiquidType
17948                                 FlowingAlt   string
17949                                 SrcAlt       string
17950                                 Viscosity    uint8 // 0-7
17951                                 LiqRenewable bool
17952                                 FlowRange    uint8
17953                                 DrownDmg     uint8
17954                                 Floodable    bool
17955
17956                                 DrawBox, ColBox, SelBox NodeBox
17957
17958                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17959
17960                                 LegacyFaceDir bool
17961                                 LegacyMounted bool
17962
17963                                 DigPredict string
17964
17965                                 MaxLvl uint8
17966
17967                                 AlphaUse
17968                         }))(obj)).LegacyMounted
17969                         if x {
17970                                 write8(w, 1)
17971                         } else {
17972                                 write8(w, 0)
17973                         }
17974                 }
17975                 if len(([]byte((*(*(struct {
17976                         Param0 Content
17977
17978                         Name   string
17979                         Groups []Group
17980
17981                         P1Type   Param1Type
17982                         P2Type   Param2Type
17983                         DrawType DrawType
17984
17985                         Mesh  string
17986                         Scale float32
17987                         //mt:const uint8(6)
17988                         Tiles        [6]TileDef
17989                         OverlayTiles [6]TileDef
17990                         //mt:const uint8(6)
17991                         SpecialTiles [6]TileDef
17992
17993                         Color   color.NRGBA
17994                         Palette Texture
17995
17996                         Waving       WaveType
17997                         ConnectSides uint8
17998                         ConnectTo    []Content
17999                         InsideTint   color.NRGBA
18000                         Level        uint8 // Must be < 128.
18001
18002                         Translucent bool // Sunlight is scattered and becomes normal light.
18003                         Transparent bool // Sunlight isn't scattered.
18004                         LightSrc    uint8
18005
18006                         GndContent   bool
18007                         Collides     bool
18008                         Pointable    bool
18009                         Diggable     bool
18010                         Climbable    bool
18011                         Replaceable  bool
18012                         OnRightClick bool
18013
18014                         DmgPerSec int32
18015
18016                         LiquidType   LiquidType
18017                         FlowingAlt   string
18018                         SrcAlt       string
18019                         Viscosity    uint8 // 0-7
18020                         LiqRenewable bool
18021                         FlowRange    uint8
18022                         DrownDmg     uint8
18023                         Floodable    bool
18024
18025                         DrawBox, ColBox, SelBox NodeBox
18026
18027                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18028
18029                         LegacyFaceDir bool
18030                         LegacyMounted bool
18031
18032                         DigPredict string
18033
18034                         MaxLvl uint8
18035
18036                         AlphaUse
18037                 }))(obj)).DigPredict))) > math.MaxUint16 {
18038                         chk(ErrTooLong)
18039                 }
18040                 {
18041                         x := uint16(len(([]byte((*(*(struct {
18042                                 Param0 Content
18043
18044                                 Name   string
18045                                 Groups []Group
18046
18047                                 P1Type   Param1Type
18048                                 P2Type   Param2Type
18049                                 DrawType DrawType
18050
18051                                 Mesh  string
18052                                 Scale float32
18053                                 //mt:const uint8(6)
18054                                 Tiles        [6]TileDef
18055                                 OverlayTiles [6]TileDef
18056                                 //mt:const uint8(6)
18057                                 SpecialTiles [6]TileDef
18058
18059                                 Color   color.NRGBA
18060                                 Palette Texture
18061
18062                                 Waving       WaveType
18063                                 ConnectSides uint8
18064                                 ConnectTo    []Content
18065                                 InsideTint   color.NRGBA
18066                                 Level        uint8 // Must be < 128.
18067
18068                                 Translucent bool // Sunlight is scattered and becomes normal light.
18069                                 Transparent bool // Sunlight isn't scattered.
18070                                 LightSrc    uint8
18071
18072                                 GndContent   bool
18073                                 Collides     bool
18074                                 Pointable    bool
18075                                 Diggable     bool
18076                                 Climbable    bool
18077                                 Replaceable  bool
18078                                 OnRightClick bool
18079
18080                                 DmgPerSec int32
18081
18082                                 LiquidType   LiquidType
18083                                 FlowingAlt   string
18084                                 SrcAlt       string
18085                                 Viscosity    uint8 // 0-7
18086                                 LiqRenewable bool
18087                                 FlowRange    uint8
18088                                 DrownDmg     uint8
18089                                 Floodable    bool
18090
18091                                 DrawBox, ColBox, SelBox NodeBox
18092
18093                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18094
18095                                 LegacyFaceDir bool
18096                                 LegacyMounted bool
18097
18098                                 DigPredict string
18099
18100                                 MaxLvl uint8
18101
18102                                 AlphaUse
18103                         }))(obj)).DigPredict))))
18104                         write16(w, uint16(x))
18105                 }
18106                 {
18107                         _, err := w.Write(([]byte((*(*(struct {
18108                                 Param0 Content
18109
18110                                 Name   string
18111                                 Groups []Group
18112
18113                                 P1Type   Param1Type
18114                                 P2Type   Param2Type
18115                                 DrawType DrawType
18116
18117                                 Mesh  string
18118                                 Scale float32
18119                                 //mt:const uint8(6)
18120                                 Tiles        [6]TileDef
18121                                 OverlayTiles [6]TileDef
18122                                 //mt:const uint8(6)
18123                                 SpecialTiles [6]TileDef
18124
18125                                 Color   color.NRGBA
18126                                 Palette Texture
18127
18128                                 Waving       WaveType
18129                                 ConnectSides uint8
18130                                 ConnectTo    []Content
18131                                 InsideTint   color.NRGBA
18132                                 Level        uint8 // Must be < 128.
18133
18134                                 Translucent bool // Sunlight is scattered and becomes normal light.
18135                                 Transparent bool // Sunlight isn't scattered.
18136                                 LightSrc    uint8
18137
18138                                 GndContent   bool
18139                                 Collides     bool
18140                                 Pointable    bool
18141                                 Diggable     bool
18142                                 Climbable    bool
18143                                 Replaceable  bool
18144                                 OnRightClick bool
18145
18146                                 DmgPerSec int32
18147
18148                                 LiquidType   LiquidType
18149                                 FlowingAlt   string
18150                                 SrcAlt       string
18151                                 Viscosity    uint8 // 0-7
18152                                 LiqRenewable bool
18153                                 FlowRange    uint8
18154                                 DrownDmg     uint8
18155                                 Floodable    bool
18156
18157                                 DrawBox, ColBox, SelBox NodeBox
18158
18159                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18160
18161                                 LegacyFaceDir bool
18162                                 LegacyMounted bool
18163
18164                                 DigPredict string
18165
18166                                 MaxLvl uint8
18167
18168                                 AlphaUse
18169                         }))(obj)).DigPredict))[:])
18170                         chk(err)
18171                 }
18172                 {
18173                         x := (*(*(struct {
18174                                 Param0 Content
18175
18176                                 Name   string
18177                                 Groups []Group
18178
18179                                 P1Type   Param1Type
18180                                 P2Type   Param2Type
18181                                 DrawType DrawType
18182
18183                                 Mesh  string
18184                                 Scale float32
18185                                 //mt:const uint8(6)
18186                                 Tiles        [6]TileDef
18187                                 OverlayTiles [6]TileDef
18188                                 //mt:const uint8(6)
18189                                 SpecialTiles [6]TileDef
18190
18191                                 Color   color.NRGBA
18192                                 Palette Texture
18193
18194                                 Waving       WaveType
18195                                 ConnectSides uint8
18196                                 ConnectTo    []Content
18197                                 InsideTint   color.NRGBA
18198                                 Level        uint8 // Must be < 128.
18199
18200                                 Translucent bool // Sunlight is scattered and becomes normal light.
18201                                 Transparent bool // Sunlight isn't scattered.
18202                                 LightSrc    uint8
18203
18204                                 GndContent   bool
18205                                 Collides     bool
18206                                 Pointable    bool
18207                                 Diggable     bool
18208                                 Climbable    bool
18209                                 Replaceable  bool
18210                                 OnRightClick bool
18211
18212                                 DmgPerSec int32
18213
18214                                 LiquidType   LiquidType
18215                                 FlowingAlt   string
18216                                 SrcAlt       string
18217                                 Viscosity    uint8 // 0-7
18218                                 LiqRenewable bool
18219                                 FlowRange    uint8
18220                                 DrownDmg     uint8
18221                                 Floodable    bool
18222
18223                                 DrawBox, ColBox, SelBox NodeBox
18224
18225                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18226
18227                                 LegacyFaceDir bool
18228                                 LegacyMounted bool
18229
18230                                 DigPredict string
18231
18232                                 MaxLvl uint8
18233
18234                                 AlphaUse
18235                         }))(obj)).MaxLvl
18236                         write8(w, uint8(x))
18237                 }
18238                 if err := pcall(func() {
18239                         ((*(*(struct {
18240                                 Param0 Content
18241
18242                                 Name   string
18243                                 Groups []Group
18244
18245                                 P1Type   Param1Type
18246                                 P2Type   Param2Type
18247                                 DrawType DrawType
18248
18249                                 Mesh  string
18250                                 Scale float32
18251                                 //mt:const uint8(6)
18252                                 Tiles        [6]TileDef
18253                                 OverlayTiles [6]TileDef
18254                                 //mt:const uint8(6)
18255                                 SpecialTiles [6]TileDef
18256
18257                                 Color   color.NRGBA
18258                                 Palette Texture
18259
18260                                 Waving       WaveType
18261                                 ConnectSides uint8
18262                                 ConnectTo    []Content
18263                                 InsideTint   color.NRGBA
18264                                 Level        uint8 // Must be < 128.
18265
18266                                 Translucent bool // Sunlight is scattered and becomes normal light.
18267                                 Transparent bool // Sunlight isn't scattered.
18268                                 LightSrc    uint8
18269
18270                                 GndContent   bool
18271                                 Collides     bool
18272                                 Pointable    bool
18273                                 Diggable     bool
18274                                 Climbable    bool
18275                                 Replaceable  bool
18276                                 OnRightClick bool
18277
18278                                 DmgPerSec int32
18279
18280                                 LiquidType   LiquidType
18281                                 FlowingAlt   string
18282                                 SrcAlt       string
18283                                 Viscosity    uint8 // 0-7
18284                                 LiqRenewable bool
18285                                 FlowRange    uint8
18286                                 DrownDmg     uint8
18287                                 Floodable    bool
18288
18289                                 DrawBox, ColBox, SelBox NodeBox
18290
18291                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18292
18293                                 LegacyFaceDir bool
18294                                 LegacyMounted bool
18295
18296                                 DigPredict string
18297
18298                                 MaxLvl uint8
18299
18300                                 AlphaUse
18301                         }))(obj)).AlphaUse).serialize(w)
18302                 }); err != nil {
18303                         if err == io.EOF {
18304                                 chk(io.EOF)
18305                         }
18306                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlphaUse", err))
18307                 }
18308                 {
18309                         buf := w
18310                         w := ow
18311                         if len((buf.Bytes())) > math.MaxUint16 {
18312                                 chk(ErrTooLong)
18313                         }
18314                         {
18315                                 x := uint16(len((buf.Bytes())))
18316                                 write16(w, uint16(x))
18317                         }
18318                         {
18319                                 _, err := w.Write((buf.Bytes())[:])
18320                                 chk(err)
18321                         }
18322                 }
18323         }
18324 }
18325
18326 func (obj *NodeDef) deserialize(r io.Reader) {
18327         if err := pcall(func() {
18328                 ((*(*(struct {
18329                         Param0 Content
18330
18331                         Name   string
18332                         Groups []Group
18333
18334                         P1Type   Param1Type
18335                         P2Type   Param2Type
18336                         DrawType DrawType
18337
18338                         Mesh  string
18339                         Scale float32
18340                         //mt:const uint8(6)
18341                         Tiles        [6]TileDef
18342                         OverlayTiles [6]TileDef
18343                         //mt:const uint8(6)
18344                         SpecialTiles [6]TileDef
18345
18346                         Color   color.NRGBA
18347                         Palette Texture
18348
18349                         Waving       WaveType
18350                         ConnectSides uint8
18351                         ConnectTo    []Content
18352                         InsideTint   color.NRGBA
18353                         Level        uint8 // Must be < 128.
18354
18355                         Translucent bool // Sunlight is scattered and becomes normal light.
18356                         Transparent bool // Sunlight isn't scattered.
18357                         LightSrc    uint8
18358
18359                         GndContent   bool
18360                         Collides     bool
18361                         Pointable    bool
18362                         Diggable     bool
18363                         Climbable    bool
18364                         Replaceable  bool
18365                         OnRightClick bool
18366
18367                         DmgPerSec int32
18368
18369                         LiquidType   LiquidType
18370                         FlowingAlt   string
18371                         SrcAlt       string
18372                         Viscosity    uint8 // 0-7
18373                         LiqRenewable bool
18374                         FlowRange    uint8
18375                         DrownDmg     uint8
18376                         Floodable    bool
18377
18378                         DrawBox, ColBox, SelBox NodeBox
18379
18380                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18381
18382                         LegacyFaceDir bool
18383                         LegacyMounted bool
18384
18385                         DigPredict string
18386
18387                         MaxLvl uint8
18388
18389                         AlphaUse
18390                 }))(obj)).Param0).deserialize(r)
18391         }); err != nil {
18392                 if err == io.EOF {
18393                         chk(io.EOF)
18394                 }
18395                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
18396         }
18397         {
18398                 var n uint16
18399                 {
18400                         p := &n
18401                         *p = read16(r)
18402                 }
18403                 r := &io.LimitedReader{R: r, N: int64(n)}
18404                 {
18405                         var local246 uint8
18406                         local247 := uint8(13)
18407                         {
18408                                 p := &local246
18409                                 *p = read8(r)
18410                         }
18411                         if local246 != local247 {
18412                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
18413                         }
18414                 }
18415                 var local248 []uint8
18416                 var local249 uint16
18417                 {
18418                         p := &local249
18419                         *p = read16(r)
18420                 }
18421                 (local248) = make([]uint8, local249)
18422                 {
18423                         _, err := io.ReadFull(r, (local248)[:])
18424                         chk(err)
18425                 }
18426                 ((*(*(struct {
18427                         Param0 Content
18428
18429                         Name   string
18430                         Groups []Group
18431
18432                         P1Type   Param1Type
18433                         P2Type   Param2Type
18434                         DrawType DrawType
18435
18436                         Mesh  string
18437                         Scale float32
18438                         //mt:const uint8(6)
18439                         Tiles        [6]TileDef
18440                         OverlayTiles [6]TileDef
18441                         //mt:const uint8(6)
18442                         SpecialTiles [6]TileDef
18443
18444                         Color   color.NRGBA
18445                         Palette Texture
18446
18447                         Waving       WaveType
18448                         ConnectSides uint8
18449                         ConnectTo    []Content
18450                         InsideTint   color.NRGBA
18451                         Level        uint8 // Must be < 128.
18452
18453                         Translucent bool // Sunlight is scattered and becomes normal light.
18454                         Transparent bool // Sunlight isn't scattered.
18455                         LightSrc    uint8
18456
18457                         GndContent   bool
18458                         Collides     bool
18459                         Pointable    bool
18460                         Diggable     bool
18461                         Climbable    bool
18462                         Replaceable  bool
18463                         OnRightClick bool
18464
18465                         DmgPerSec int32
18466
18467                         LiquidType   LiquidType
18468                         FlowingAlt   string
18469                         SrcAlt       string
18470                         Viscosity    uint8 // 0-7
18471                         LiqRenewable bool
18472                         FlowRange    uint8
18473                         DrownDmg     uint8
18474                         Floodable    bool
18475
18476                         DrawBox, ColBox, SelBox NodeBox
18477
18478                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18479
18480                         LegacyFaceDir bool
18481                         LegacyMounted bool
18482
18483                         DigPredict string
18484
18485                         MaxLvl uint8
18486
18487                         AlphaUse
18488                 }))(obj)).Name) = string(local248)
18489                 var local250 uint16
18490                 {
18491                         p := &local250
18492                         *p = read16(r)
18493                 }
18494                 ((*(*(struct {
18495                         Param0 Content
18496
18497                         Name   string
18498                         Groups []Group
18499
18500                         P1Type   Param1Type
18501                         P2Type   Param2Type
18502                         DrawType DrawType
18503
18504                         Mesh  string
18505                         Scale float32
18506                         //mt:const uint8(6)
18507                         Tiles        [6]TileDef
18508                         OverlayTiles [6]TileDef
18509                         //mt:const uint8(6)
18510                         SpecialTiles [6]TileDef
18511
18512                         Color   color.NRGBA
18513                         Palette Texture
18514
18515                         Waving       WaveType
18516                         ConnectSides uint8
18517                         ConnectTo    []Content
18518                         InsideTint   color.NRGBA
18519                         Level        uint8 // Must be < 128.
18520
18521                         Translucent bool // Sunlight is scattered and becomes normal light.
18522                         Transparent bool // Sunlight isn't scattered.
18523                         LightSrc    uint8
18524
18525                         GndContent   bool
18526                         Collides     bool
18527                         Pointable    bool
18528                         Diggable     bool
18529                         Climbable    bool
18530                         Replaceable  bool
18531                         OnRightClick bool
18532
18533                         DmgPerSec int32
18534
18535                         LiquidType   LiquidType
18536                         FlowingAlt   string
18537                         SrcAlt       string
18538                         Viscosity    uint8 // 0-7
18539                         LiqRenewable bool
18540                         FlowRange    uint8
18541                         DrownDmg     uint8
18542                         Floodable    bool
18543
18544                         DrawBox, ColBox, SelBox NodeBox
18545
18546                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18547
18548                         LegacyFaceDir bool
18549                         LegacyMounted bool
18550
18551                         DigPredict string
18552
18553                         MaxLvl uint8
18554
18555                         AlphaUse
18556                 }))(obj)).Groups) = make([]Group, local250)
18557                 for local251 := range (*(*(struct {
18558                         Param0 Content
18559
18560                         Name   string
18561                         Groups []Group
18562
18563                         P1Type   Param1Type
18564                         P2Type   Param2Type
18565                         DrawType DrawType
18566
18567                         Mesh  string
18568                         Scale float32
18569                         //mt:const uint8(6)
18570                         Tiles        [6]TileDef
18571                         OverlayTiles [6]TileDef
18572                         //mt:const uint8(6)
18573                         SpecialTiles [6]TileDef
18574
18575                         Color   color.NRGBA
18576                         Palette Texture
18577
18578                         Waving       WaveType
18579                         ConnectSides uint8
18580                         ConnectTo    []Content
18581                         InsideTint   color.NRGBA
18582                         Level        uint8 // Must be < 128.
18583
18584                         Translucent bool // Sunlight is scattered and becomes normal light.
18585                         Transparent bool // Sunlight isn't scattered.
18586                         LightSrc    uint8
18587
18588                         GndContent   bool
18589                         Collides     bool
18590                         Pointable    bool
18591                         Diggable     bool
18592                         Climbable    bool
18593                         Replaceable  bool
18594                         OnRightClick bool
18595
18596                         DmgPerSec int32
18597
18598                         LiquidType   LiquidType
18599                         FlowingAlt   string
18600                         SrcAlt       string
18601                         Viscosity    uint8 // 0-7
18602                         LiqRenewable bool
18603                         FlowRange    uint8
18604                         DrownDmg     uint8
18605                         Floodable    bool
18606
18607                         DrawBox, ColBox, SelBox NodeBox
18608
18609                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18610
18611                         LegacyFaceDir bool
18612                         LegacyMounted bool
18613
18614                         DigPredict string
18615
18616                         MaxLvl uint8
18617
18618                         AlphaUse
18619                 }))(obj)).Groups {
18620                         if err := pcall(func() {
18621                                 (((*(*(struct {
18622                                         Param0 Content
18623
18624                                         Name   string
18625                                         Groups []Group
18626
18627                                         P1Type   Param1Type
18628                                         P2Type   Param2Type
18629                                         DrawType DrawType
18630
18631                                         Mesh  string
18632                                         Scale float32
18633                                         //mt:const uint8(6)
18634                                         Tiles        [6]TileDef
18635                                         OverlayTiles [6]TileDef
18636                                         //mt:const uint8(6)
18637                                         SpecialTiles [6]TileDef
18638
18639                                         Color   color.NRGBA
18640                                         Palette Texture
18641
18642                                         Waving       WaveType
18643                                         ConnectSides uint8
18644                                         ConnectTo    []Content
18645                                         InsideTint   color.NRGBA
18646                                         Level        uint8 // Must be < 128.
18647
18648                                         Translucent bool // Sunlight is scattered and becomes normal light.
18649                                         Transparent bool // Sunlight isn't scattered.
18650                                         LightSrc    uint8
18651
18652                                         GndContent   bool
18653                                         Collides     bool
18654                                         Pointable    bool
18655                                         Diggable     bool
18656                                         Climbable    bool
18657                                         Replaceable  bool
18658                                         OnRightClick bool
18659
18660                                         DmgPerSec int32
18661
18662                                         LiquidType   LiquidType
18663                                         FlowingAlt   string
18664                                         SrcAlt       string
18665                                         Viscosity    uint8 // 0-7
18666                                         LiqRenewable bool
18667                                         FlowRange    uint8
18668                                         DrownDmg     uint8
18669                                         Floodable    bool
18670
18671                                         DrawBox, ColBox, SelBox NodeBox
18672
18673                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18674
18675                                         LegacyFaceDir bool
18676                                         LegacyMounted bool
18677
18678                                         DigPredict string
18679
18680                                         MaxLvl uint8
18681
18682                                         AlphaUse
18683                                 }))(obj)).Groups)[local251]).deserialize(r)
18684                         }); err != nil {
18685                                 if err == io.EOF {
18686                                         chk(io.EOF)
18687                                 }
18688                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
18689                         }
18690                 }
18691                 if err := pcall(func() {
18692                         ((*(*(struct {
18693                                 Param0 Content
18694
18695                                 Name   string
18696                                 Groups []Group
18697
18698                                 P1Type   Param1Type
18699                                 P2Type   Param2Type
18700                                 DrawType DrawType
18701
18702                                 Mesh  string
18703                                 Scale float32
18704                                 //mt:const uint8(6)
18705                                 Tiles        [6]TileDef
18706                                 OverlayTiles [6]TileDef
18707                                 //mt:const uint8(6)
18708                                 SpecialTiles [6]TileDef
18709
18710                                 Color   color.NRGBA
18711                                 Palette Texture
18712
18713                                 Waving       WaveType
18714                                 ConnectSides uint8
18715                                 ConnectTo    []Content
18716                                 InsideTint   color.NRGBA
18717                                 Level        uint8 // Must be < 128.
18718
18719                                 Translucent bool // Sunlight is scattered and becomes normal light.
18720                                 Transparent bool // Sunlight isn't scattered.
18721                                 LightSrc    uint8
18722
18723                                 GndContent   bool
18724                                 Collides     bool
18725                                 Pointable    bool
18726                                 Diggable     bool
18727                                 Climbable    bool
18728                                 Replaceable  bool
18729                                 OnRightClick bool
18730
18731                                 DmgPerSec int32
18732
18733                                 LiquidType   LiquidType
18734                                 FlowingAlt   string
18735                                 SrcAlt       string
18736                                 Viscosity    uint8 // 0-7
18737                                 LiqRenewable bool
18738                                 FlowRange    uint8
18739                                 DrownDmg     uint8
18740                                 Floodable    bool
18741
18742                                 DrawBox, ColBox, SelBox NodeBox
18743
18744                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18745
18746                                 LegacyFaceDir bool
18747                                 LegacyMounted bool
18748
18749                                 DigPredict string
18750
18751                                 MaxLvl uint8
18752
18753                                 AlphaUse
18754                         }))(obj)).P1Type).deserialize(r)
18755                 }); err != nil {
18756                         if err == io.EOF {
18757                                 chk(io.EOF)
18758                         }
18759                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param1Type", err))
18760                 }
18761                 if err := pcall(func() {
18762                         ((*(*(struct {
18763                                 Param0 Content
18764
18765                                 Name   string
18766                                 Groups []Group
18767
18768                                 P1Type   Param1Type
18769                                 P2Type   Param2Type
18770                                 DrawType DrawType
18771
18772                                 Mesh  string
18773                                 Scale float32
18774                                 //mt:const uint8(6)
18775                                 Tiles        [6]TileDef
18776                                 OverlayTiles [6]TileDef
18777                                 //mt:const uint8(6)
18778                                 SpecialTiles [6]TileDef
18779
18780                                 Color   color.NRGBA
18781                                 Palette Texture
18782
18783                                 Waving       WaveType
18784                                 ConnectSides uint8
18785                                 ConnectTo    []Content
18786                                 InsideTint   color.NRGBA
18787                                 Level        uint8 // Must be < 128.
18788
18789                                 Translucent bool // Sunlight is scattered and becomes normal light.
18790                                 Transparent bool // Sunlight isn't scattered.
18791                                 LightSrc    uint8
18792
18793                                 GndContent   bool
18794                                 Collides     bool
18795                                 Pointable    bool
18796                                 Diggable     bool
18797                                 Climbable    bool
18798                                 Replaceable  bool
18799                                 OnRightClick bool
18800
18801                                 DmgPerSec int32
18802
18803                                 LiquidType   LiquidType
18804                                 FlowingAlt   string
18805                                 SrcAlt       string
18806                                 Viscosity    uint8 // 0-7
18807                                 LiqRenewable bool
18808                                 FlowRange    uint8
18809                                 DrownDmg     uint8
18810                                 Floodable    bool
18811
18812                                 DrawBox, ColBox, SelBox NodeBox
18813
18814                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18815
18816                                 LegacyFaceDir bool
18817                                 LegacyMounted bool
18818
18819                                 DigPredict string
18820
18821                                 MaxLvl uint8
18822
18823                                 AlphaUse
18824                         }))(obj)).P2Type).deserialize(r)
18825                 }); err != nil {
18826                         if err == io.EOF {
18827                                 chk(io.EOF)
18828                         }
18829                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param2Type", err))
18830                 }
18831                 if err := pcall(func() {
18832                         ((*(*(struct {
18833                                 Param0 Content
18834
18835                                 Name   string
18836                                 Groups []Group
18837
18838                                 P1Type   Param1Type
18839                                 P2Type   Param2Type
18840                                 DrawType DrawType
18841
18842                                 Mesh  string
18843                                 Scale float32
18844                                 //mt:const uint8(6)
18845                                 Tiles        [6]TileDef
18846                                 OverlayTiles [6]TileDef
18847                                 //mt:const uint8(6)
18848                                 SpecialTiles [6]TileDef
18849
18850                                 Color   color.NRGBA
18851                                 Palette Texture
18852
18853                                 Waving       WaveType
18854                                 ConnectSides uint8
18855                                 ConnectTo    []Content
18856                                 InsideTint   color.NRGBA
18857                                 Level        uint8 // Must be < 128.
18858
18859                                 Translucent bool // Sunlight is scattered and becomes normal light.
18860                                 Transparent bool // Sunlight isn't scattered.
18861                                 LightSrc    uint8
18862
18863                                 GndContent   bool
18864                                 Collides     bool
18865                                 Pointable    bool
18866                                 Diggable     bool
18867                                 Climbable    bool
18868                                 Replaceable  bool
18869                                 OnRightClick bool
18870
18871                                 DmgPerSec int32
18872
18873                                 LiquidType   LiquidType
18874                                 FlowingAlt   string
18875                                 SrcAlt       string
18876                                 Viscosity    uint8 // 0-7
18877                                 LiqRenewable bool
18878                                 FlowRange    uint8
18879                                 DrownDmg     uint8
18880                                 Floodable    bool
18881
18882                                 DrawBox, ColBox, SelBox NodeBox
18883
18884                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18885
18886                                 LegacyFaceDir bool
18887                                 LegacyMounted bool
18888
18889                                 DigPredict string
18890
18891                                 MaxLvl uint8
18892
18893                                 AlphaUse
18894                         }))(obj)).DrawType).deserialize(r)
18895                 }); err != nil {
18896                         if err == io.EOF {
18897                                 chk(io.EOF)
18898                         }
18899                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DrawType", err))
18900                 }
18901                 var local252 []uint8
18902                 var local253 uint16
18903                 {
18904                         p := &local253
18905                         *p = read16(r)
18906                 }
18907                 (local252) = make([]uint8, local253)
18908                 {
18909                         _, err := io.ReadFull(r, (local252)[:])
18910                         chk(err)
18911                 }
18912                 ((*(*(struct {
18913                         Param0 Content
18914
18915                         Name   string
18916                         Groups []Group
18917
18918                         P1Type   Param1Type
18919                         P2Type   Param2Type
18920                         DrawType DrawType
18921
18922                         Mesh  string
18923                         Scale float32
18924                         //mt:const uint8(6)
18925                         Tiles        [6]TileDef
18926                         OverlayTiles [6]TileDef
18927                         //mt:const uint8(6)
18928                         SpecialTiles [6]TileDef
18929
18930                         Color   color.NRGBA
18931                         Palette Texture
18932
18933                         Waving       WaveType
18934                         ConnectSides uint8
18935                         ConnectTo    []Content
18936                         InsideTint   color.NRGBA
18937                         Level        uint8 // Must be < 128.
18938
18939                         Translucent bool // Sunlight is scattered and becomes normal light.
18940                         Transparent bool // Sunlight isn't scattered.
18941                         LightSrc    uint8
18942
18943                         GndContent   bool
18944                         Collides     bool
18945                         Pointable    bool
18946                         Diggable     bool
18947                         Climbable    bool
18948                         Replaceable  bool
18949                         OnRightClick bool
18950
18951                         DmgPerSec int32
18952
18953                         LiquidType   LiquidType
18954                         FlowingAlt   string
18955                         SrcAlt       string
18956                         Viscosity    uint8 // 0-7
18957                         LiqRenewable bool
18958                         FlowRange    uint8
18959                         DrownDmg     uint8
18960                         Floodable    bool
18961
18962                         DrawBox, ColBox, SelBox NodeBox
18963
18964                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18965
18966                         LegacyFaceDir bool
18967                         LegacyMounted bool
18968
18969                         DigPredict string
18970
18971                         MaxLvl uint8
18972
18973                         AlphaUse
18974                 }))(obj)).Mesh) = string(local252)
18975                 {
18976                         p := &(*(*(struct {
18977                                 Param0 Content
18978
18979                                 Name   string
18980                                 Groups []Group
18981
18982                                 P1Type   Param1Type
18983                                 P2Type   Param2Type
18984                                 DrawType DrawType
18985
18986                                 Mesh  string
18987                                 Scale float32
18988                                 //mt:const uint8(6)
18989                                 Tiles        [6]TileDef
18990                                 OverlayTiles [6]TileDef
18991                                 //mt:const uint8(6)
18992                                 SpecialTiles [6]TileDef
18993
18994                                 Color   color.NRGBA
18995                                 Palette Texture
18996
18997                                 Waving       WaveType
18998                                 ConnectSides uint8
18999                                 ConnectTo    []Content
19000                                 InsideTint   color.NRGBA
19001                                 Level        uint8 // Must be < 128.
19002
19003                                 Translucent bool // Sunlight is scattered and becomes normal light.
19004                                 Transparent bool // Sunlight isn't scattered.
19005                                 LightSrc    uint8
19006
19007                                 GndContent   bool
19008                                 Collides     bool
19009                                 Pointable    bool
19010                                 Diggable     bool
19011                                 Climbable    bool
19012                                 Replaceable  bool
19013                                 OnRightClick bool
19014
19015                                 DmgPerSec int32
19016
19017                                 LiquidType   LiquidType
19018                                 FlowingAlt   string
19019                                 SrcAlt       string
19020                                 Viscosity    uint8 // 0-7
19021                                 LiqRenewable bool
19022                                 FlowRange    uint8
19023                                 DrownDmg     uint8
19024                                 Floodable    bool
19025
19026                                 DrawBox, ColBox, SelBox NodeBox
19027
19028                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19029
19030                                 LegacyFaceDir bool
19031                                 LegacyMounted bool
19032
19033                                 DigPredict string
19034
19035                                 MaxLvl uint8
19036
19037                                 AlphaUse
19038                         }))(obj)).Scale
19039                         *p = math.Float32frombits(read32(r))
19040                 }
19041                 {
19042                         var local254 uint8
19043                         local255 := uint8(6)
19044                         {
19045                                 p := &local254
19046                                 *p = read8(r)
19047                         }
19048                         if local254 != local255 {
19049                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
19050                         }
19051                 }
19052                 for local256 := range (*(*(struct {
19053                         Param0 Content
19054
19055                         Name   string
19056                         Groups []Group
19057
19058                         P1Type   Param1Type
19059                         P2Type   Param2Type
19060                         DrawType DrawType
19061
19062                         Mesh  string
19063                         Scale float32
19064                         //mt:const uint8(6)
19065                         Tiles        [6]TileDef
19066                         OverlayTiles [6]TileDef
19067                         //mt:const uint8(6)
19068                         SpecialTiles [6]TileDef
19069
19070                         Color   color.NRGBA
19071                         Palette Texture
19072
19073                         Waving       WaveType
19074                         ConnectSides uint8
19075                         ConnectTo    []Content
19076                         InsideTint   color.NRGBA
19077                         Level        uint8 // Must be < 128.
19078
19079                         Translucent bool // Sunlight is scattered and becomes normal light.
19080                         Transparent bool // Sunlight isn't scattered.
19081                         LightSrc    uint8
19082
19083                         GndContent   bool
19084                         Collides     bool
19085                         Pointable    bool
19086                         Diggable     bool
19087                         Climbable    bool
19088                         Replaceable  bool
19089                         OnRightClick bool
19090
19091                         DmgPerSec int32
19092
19093                         LiquidType   LiquidType
19094                         FlowingAlt   string
19095                         SrcAlt       string
19096                         Viscosity    uint8 // 0-7
19097                         LiqRenewable bool
19098                         FlowRange    uint8
19099                         DrownDmg     uint8
19100                         Floodable    bool
19101
19102                         DrawBox, ColBox, SelBox NodeBox
19103
19104                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19105
19106                         LegacyFaceDir bool
19107                         LegacyMounted bool
19108
19109                         DigPredict string
19110
19111                         MaxLvl uint8
19112
19113                         AlphaUse
19114                 }))(obj)).Tiles {
19115                         if err := pcall(func() {
19116                                 (((*(*(struct {
19117                                         Param0 Content
19118
19119                                         Name   string
19120                                         Groups []Group
19121
19122                                         P1Type   Param1Type
19123                                         P2Type   Param2Type
19124                                         DrawType DrawType
19125
19126                                         Mesh  string
19127                                         Scale float32
19128                                         //mt:const uint8(6)
19129                                         Tiles        [6]TileDef
19130                                         OverlayTiles [6]TileDef
19131                                         //mt:const uint8(6)
19132                                         SpecialTiles [6]TileDef
19133
19134                                         Color   color.NRGBA
19135                                         Palette Texture
19136
19137                                         Waving       WaveType
19138                                         ConnectSides uint8
19139                                         ConnectTo    []Content
19140                                         InsideTint   color.NRGBA
19141                                         Level        uint8 // Must be < 128.
19142
19143                                         Translucent bool // Sunlight is scattered and becomes normal light.
19144                                         Transparent bool // Sunlight isn't scattered.
19145                                         LightSrc    uint8
19146
19147                                         GndContent   bool
19148                                         Collides     bool
19149                                         Pointable    bool
19150                                         Diggable     bool
19151                                         Climbable    bool
19152                                         Replaceable  bool
19153                                         OnRightClick bool
19154
19155                                         DmgPerSec int32
19156
19157                                         LiquidType   LiquidType
19158                                         FlowingAlt   string
19159                                         SrcAlt       string
19160                                         Viscosity    uint8 // 0-7
19161                                         LiqRenewable bool
19162                                         FlowRange    uint8
19163                                         DrownDmg     uint8
19164                                         Floodable    bool
19165
19166                                         DrawBox, ColBox, SelBox NodeBox
19167
19168                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19169
19170                                         LegacyFaceDir bool
19171                                         LegacyMounted bool
19172
19173                                         DigPredict string
19174
19175                                         MaxLvl uint8
19176
19177                                         AlphaUse
19178                                 }))(obj)).Tiles)[local256]).deserialize(r)
19179                         }); err != nil {
19180                                 if err == io.EOF {
19181                                         chk(io.EOF)
19182                                 }
19183                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
19184                         }
19185                 }
19186                 for local257 := range (*(*(struct {
19187                         Param0 Content
19188
19189                         Name   string
19190                         Groups []Group
19191
19192                         P1Type   Param1Type
19193                         P2Type   Param2Type
19194                         DrawType DrawType
19195
19196                         Mesh  string
19197                         Scale float32
19198                         //mt:const uint8(6)
19199                         Tiles        [6]TileDef
19200                         OverlayTiles [6]TileDef
19201                         //mt:const uint8(6)
19202                         SpecialTiles [6]TileDef
19203
19204                         Color   color.NRGBA
19205                         Palette Texture
19206
19207                         Waving       WaveType
19208                         ConnectSides uint8
19209                         ConnectTo    []Content
19210                         InsideTint   color.NRGBA
19211                         Level        uint8 // Must be < 128.
19212
19213                         Translucent bool // Sunlight is scattered and becomes normal light.
19214                         Transparent bool // Sunlight isn't scattered.
19215                         LightSrc    uint8
19216
19217                         GndContent   bool
19218                         Collides     bool
19219                         Pointable    bool
19220                         Diggable     bool
19221                         Climbable    bool
19222                         Replaceable  bool
19223                         OnRightClick bool
19224
19225                         DmgPerSec int32
19226
19227                         LiquidType   LiquidType
19228                         FlowingAlt   string
19229                         SrcAlt       string
19230                         Viscosity    uint8 // 0-7
19231                         LiqRenewable bool
19232                         FlowRange    uint8
19233                         DrownDmg     uint8
19234                         Floodable    bool
19235
19236                         DrawBox, ColBox, SelBox NodeBox
19237
19238                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19239
19240                         LegacyFaceDir bool
19241                         LegacyMounted bool
19242
19243                         DigPredict string
19244
19245                         MaxLvl uint8
19246
19247                         AlphaUse
19248                 }))(obj)).OverlayTiles {
19249                         if err := pcall(func() {
19250                                 (((*(*(struct {
19251                                         Param0 Content
19252
19253                                         Name   string
19254                                         Groups []Group
19255
19256                                         P1Type   Param1Type
19257                                         P2Type   Param2Type
19258                                         DrawType DrawType
19259
19260                                         Mesh  string
19261                                         Scale float32
19262                                         //mt:const uint8(6)
19263                                         Tiles        [6]TileDef
19264                                         OverlayTiles [6]TileDef
19265                                         //mt:const uint8(6)
19266                                         SpecialTiles [6]TileDef
19267
19268                                         Color   color.NRGBA
19269                                         Palette Texture
19270
19271                                         Waving       WaveType
19272                                         ConnectSides uint8
19273                                         ConnectTo    []Content
19274                                         InsideTint   color.NRGBA
19275                                         Level        uint8 // Must be < 128.
19276
19277                                         Translucent bool // Sunlight is scattered and becomes normal light.
19278                                         Transparent bool // Sunlight isn't scattered.
19279                                         LightSrc    uint8
19280
19281                                         GndContent   bool
19282                                         Collides     bool
19283                                         Pointable    bool
19284                                         Diggable     bool
19285                                         Climbable    bool
19286                                         Replaceable  bool
19287                                         OnRightClick bool
19288
19289                                         DmgPerSec int32
19290
19291                                         LiquidType   LiquidType
19292                                         FlowingAlt   string
19293                                         SrcAlt       string
19294                                         Viscosity    uint8 // 0-7
19295                                         LiqRenewable bool
19296                                         FlowRange    uint8
19297                                         DrownDmg     uint8
19298                                         Floodable    bool
19299
19300                                         DrawBox, ColBox, SelBox NodeBox
19301
19302                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19303
19304                                         LegacyFaceDir bool
19305                                         LegacyMounted bool
19306
19307                                         DigPredict string
19308
19309                                         MaxLvl uint8
19310
19311                                         AlphaUse
19312                                 }))(obj)).OverlayTiles)[local257]).deserialize(r)
19313                         }); err != nil {
19314                                 if err == io.EOF {
19315                                         chk(io.EOF)
19316                                 }
19317                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
19318                         }
19319                 }
19320                 {
19321                         var local258 uint8
19322                         local259 := uint8(6)
19323                         {
19324                                 p := &local258
19325                                 *p = read8(r)
19326                         }
19327                         if local258 != local259 {
19328                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
19329                         }
19330                 }
19331                 for local260 := range (*(*(struct {
19332                         Param0 Content
19333
19334                         Name   string
19335                         Groups []Group
19336
19337                         P1Type   Param1Type
19338                         P2Type   Param2Type
19339                         DrawType DrawType
19340
19341                         Mesh  string
19342                         Scale float32
19343                         //mt:const uint8(6)
19344                         Tiles        [6]TileDef
19345                         OverlayTiles [6]TileDef
19346                         //mt:const uint8(6)
19347                         SpecialTiles [6]TileDef
19348
19349                         Color   color.NRGBA
19350                         Palette Texture
19351
19352                         Waving       WaveType
19353                         ConnectSides uint8
19354                         ConnectTo    []Content
19355                         InsideTint   color.NRGBA
19356                         Level        uint8 // Must be < 128.
19357
19358                         Translucent bool // Sunlight is scattered and becomes normal light.
19359                         Transparent bool // Sunlight isn't scattered.
19360                         LightSrc    uint8
19361
19362                         GndContent   bool
19363                         Collides     bool
19364                         Pointable    bool
19365                         Diggable     bool
19366                         Climbable    bool
19367                         Replaceable  bool
19368                         OnRightClick bool
19369
19370                         DmgPerSec int32
19371
19372                         LiquidType   LiquidType
19373                         FlowingAlt   string
19374                         SrcAlt       string
19375                         Viscosity    uint8 // 0-7
19376                         LiqRenewable bool
19377                         FlowRange    uint8
19378                         DrownDmg     uint8
19379                         Floodable    bool
19380
19381                         DrawBox, ColBox, SelBox NodeBox
19382
19383                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19384
19385                         LegacyFaceDir bool
19386                         LegacyMounted bool
19387
19388                         DigPredict string
19389
19390                         MaxLvl uint8
19391
19392                         AlphaUse
19393                 }))(obj)).SpecialTiles {
19394                         if err := pcall(func() {
19395                                 (((*(*(struct {
19396                                         Param0 Content
19397
19398                                         Name   string
19399                                         Groups []Group
19400
19401                                         P1Type   Param1Type
19402                                         P2Type   Param2Type
19403                                         DrawType DrawType
19404
19405                                         Mesh  string
19406                                         Scale float32
19407                                         //mt:const uint8(6)
19408                                         Tiles        [6]TileDef
19409                                         OverlayTiles [6]TileDef
19410                                         //mt:const uint8(6)
19411                                         SpecialTiles [6]TileDef
19412
19413                                         Color   color.NRGBA
19414                                         Palette Texture
19415
19416                                         Waving       WaveType
19417                                         ConnectSides uint8
19418                                         ConnectTo    []Content
19419                                         InsideTint   color.NRGBA
19420                                         Level        uint8 // Must be < 128.
19421
19422                                         Translucent bool // Sunlight is scattered and becomes normal light.
19423                                         Transparent bool // Sunlight isn't scattered.
19424                                         LightSrc    uint8
19425
19426                                         GndContent   bool
19427                                         Collides     bool
19428                                         Pointable    bool
19429                                         Diggable     bool
19430                                         Climbable    bool
19431                                         Replaceable  bool
19432                                         OnRightClick bool
19433
19434                                         DmgPerSec int32
19435
19436                                         LiquidType   LiquidType
19437                                         FlowingAlt   string
19438                                         SrcAlt       string
19439                                         Viscosity    uint8 // 0-7
19440                                         LiqRenewable bool
19441                                         FlowRange    uint8
19442                                         DrownDmg     uint8
19443                                         Floodable    bool
19444
19445                                         DrawBox, ColBox, SelBox NodeBox
19446
19447                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19448
19449                                         LegacyFaceDir bool
19450                                         LegacyMounted bool
19451
19452                                         DigPredict string
19453
19454                                         MaxLvl uint8
19455
19456                                         AlphaUse
19457                                 }))(obj)).SpecialTiles)[local260]).deserialize(r)
19458                         }); err != nil {
19459                                 if err == io.EOF {
19460                                         chk(io.EOF)
19461                                 }
19462                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
19463                         }
19464                 }
19465                 {
19466                         p := &(*(*(struct {
19467                                 Param0 Content
19468
19469                                 Name   string
19470                                 Groups []Group
19471
19472                                 P1Type   Param1Type
19473                                 P2Type   Param2Type
19474                                 DrawType DrawType
19475
19476                                 Mesh  string
19477                                 Scale float32
19478                                 //mt:const uint8(6)
19479                                 Tiles        [6]TileDef
19480                                 OverlayTiles [6]TileDef
19481                                 //mt:const uint8(6)
19482                                 SpecialTiles [6]TileDef
19483
19484                                 Color   color.NRGBA
19485                                 Palette Texture
19486
19487                                 Waving       WaveType
19488                                 ConnectSides uint8
19489                                 ConnectTo    []Content
19490                                 InsideTint   color.NRGBA
19491                                 Level        uint8 // Must be < 128.
19492
19493                                 Translucent bool // Sunlight is scattered and becomes normal light.
19494                                 Transparent bool // Sunlight isn't scattered.
19495                                 LightSrc    uint8
19496
19497                                 GndContent   bool
19498                                 Collides     bool
19499                                 Pointable    bool
19500                                 Diggable     bool
19501                                 Climbable    bool
19502                                 Replaceable  bool
19503                                 OnRightClick bool
19504
19505                                 DmgPerSec int32
19506
19507                                 LiquidType   LiquidType
19508                                 FlowingAlt   string
19509                                 SrcAlt       string
19510                                 Viscosity    uint8 // 0-7
19511                                 LiqRenewable bool
19512                                 FlowRange    uint8
19513                                 DrownDmg     uint8
19514                                 Floodable    bool
19515
19516                                 DrawBox, ColBox, SelBox NodeBox
19517
19518                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19519
19520                                 LegacyFaceDir bool
19521                                 LegacyMounted bool
19522
19523                                 DigPredict string
19524
19525                                 MaxLvl uint8
19526
19527                                 AlphaUse
19528                         }))(obj)).Color
19529                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
19530                 }
19531                 if err := pcall(func() {
19532                         ((*(*(struct {
19533                                 Param0 Content
19534
19535                                 Name   string
19536                                 Groups []Group
19537
19538                                 P1Type   Param1Type
19539                                 P2Type   Param2Type
19540                                 DrawType DrawType
19541
19542                                 Mesh  string
19543                                 Scale float32
19544                                 //mt:const uint8(6)
19545                                 Tiles        [6]TileDef
19546                                 OverlayTiles [6]TileDef
19547                                 //mt:const uint8(6)
19548                                 SpecialTiles [6]TileDef
19549
19550                                 Color   color.NRGBA
19551                                 Palette Texture
19552
19553                                 Waving       WaveType
19554                                 ConnectSides uint8
19555                                 ConnectTo    []Content
19556                                 InsideTint   color.NRGBA
19557                                 Level        uint8 // Must be < 128.
19558
19559                                 Translucent bool // Sunlight is scattered and becomes normal light.
19560                                 Transparent bool // Sunlight isn't scattered.
19561                                 LightSrc    uint8
19562
19563                                 GndContent   bool
19564                                 Collides     bool
19565                                 Pointable    bool
19566                                 Diggable     bool
19567                                 Climbable    bool
19568                                 Replaceable  bool
19569                                 OnRightClick bool
19570
19571                                 DmgPerSec int32
19572
19573                                 LiquidType   LiquidType
19574                                 FlowingAlt   string
19575                                 SrcAlt       string
19576                                 Viscosity    uint8 // 0-7
19577                                 LiqRenewable bool
19578                                 FlowRange    uint8
19579                                 DrownDmg     uint8
19580                                 Floodable    bool
19581
19582                                 DrawBox, ColBox, SelBox NodeBox
19583
19584                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19585
19586                                 LegacyFaceDir bool
19587                                 LegacyMounted bool
19588
19589                                 DigPredict string
19590
19591                                 MaxLvl uint8
19592
19593                                 AlphaUse
19594                         }))(obj)).Palette).deserialize(r)
19595                 }); err != nil {
19596                         if err == io.EOF {
19597                                 chk(io.EOF)
19598                         }
19599                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
19600                 }
19601                 if err := pcall(func() {
19602                         ((*(*(struct {
19603                                 Param0 Content
19604
19605                                 Name   string
19606                                 Groups []Group
19607
19608                                 P1Type   Param1Type
19609                                 P2Type   Param2Type
19610                                 DrawType DrawType
19611
19612                                 Mesh  string
19613                                 Scale float32
19614                                 //mt:const uint8(6)
19615                                 Tiles        [6]TileDef
19616                                 OverlayTiles [6]TileDef
19617                                 //mt:const uint8(6)
19618                                 SpecialTiles [6]TileDef
19619
19620                                 Color   color.NRGBA
19621                                 Palette Texture
19622
19623                                 Waving       WaveType
19624                                 ConnectSides uint8
19625                                 ConnectTo    []Content
19626                                 InsideTint   color.NRGBA
19627                                 Level        uint8 // Must be < 128.
19628
19629                                 Translucent bool // Sunlight is scattered and becomes normal light.
19630                                 Transparent bool // Sunlight isn't scattered.
19631                                 LightSrc    uint8
19632
19633                                 GndContent   bool
19634                                 Collides     bool
19635                                 Pointable    bool
19636                                 Diggable     bool
19637                                 Climbable    bool
19638                                 Replaceable  bool
19639                                 OnRightClick bool
19640
19641                                 DmgPerSec int32
19642
19643                                 LiquidType   LiquidType
19644                                 FlowingAlt   string
19645                                 SrcAlt       string
19646                                 Viscosity    uint8 // 0-7
19647                                 LiqRenewable bool
19648                                 FlowRange    uint8
19649                                 DrownDmg     uint8
19650                                 Floodable    bool
19651
19652                                 DrawBox, ColBox, SelBox NodeBox
19653
19654                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19655
19656                                 LegacyFaceDir bool
19657                                 LegacyMounted bool
19658
19659                                 DigPredict string
19660
19661                                 MaxLvl uint8
19662
19663                                 AlphaUse
19664                         }))(obj)).Waving).deserialize(r)
19665                 }); err != nil {
19666                         if err == io.EOF {
19667                                 chk(io.EOF)
19668                         }
19669                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.WaveType", err))
19670                 }
19671                 {
19672                         p := &(*(*(struct {
19673                                 Param0 Content
19674
19675                                 Name   string
19676                                 Groups []Group
19677
19678                                 P1Type   Param1Type
19679                                 P2Type   Param2Type
19680                                 DrawType DrawType
19681
19682                                 Mesh  string
19683                                 Scale float32
19684                                 //mt:const uint8(6)
19685                                 Tiles        [6]TileDef
19686                                 OverlayTiles [6]TileDef
19687                                 //mt:const uint8(6)
19688                                 SpecialTiles [6]TileDef
19689
19690                                 Color   color.NRGBA
19691                                 Palette Texture
19692
19693                                 Waving       WaveType
19694                                 ConnectSides uint8
19695                                 ConnectTo    []Content
19696                                 InsideTint   color.NRGBA
19697                                 Level        uint8 // Must be < 128.
19698
19699                                 Translucent bool // Sunlight is scattered and becomes normal light.
19700                                 Transparent bool // Sunlight isn't scattered.
19701                                 LightSrc    uint8
19702
19703                                 GndContent   bool
19704                                 Collides     bool
19705                                 Pointable    bool
19706                                 Diggable     bool
19707                                 Climbable    bool
19708                                 Replaceable  bool
19709                                 OnRightClick bool
19710
19711                                 DmgPerSec int32
19712
19713                                 LiquidType   LiquidType
19714                                 FlowingAlt   string
19715                                 SrcAlt       string
19716                                 Viscosity    uint8 // 0-7
19717                                 LiqRenewable bool
19718                                 FlowRange    uint8
19719                                 DrownDmg     uint8
19720                                 Floodable    bool
19721
19722                                 DrawBox, ColBox, SelBox NodeBox
19723
19724                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19725
19726                                 LegacyFaceDir bool
19727                                 LegacyMounted bool
19728
19729                                 DigPredict string
19730
19731                                 MaxLvl uint8
19732
19733                                 AlphaUse
19734                         }))(obj)).ConnectSides
19735                         *p = read8(r)
19736                 }
19737                 var local261 uint16
19738                 {
19739                         p := &local261
19740                         *p = read16(r)
19741                 }
19742                 ((*(*(struct {
19743                         Param0 Content
19744
19745                         Name   string
19746                         Groups []Group
19747
19748                         P1Type   Param1Type
19749                         P2Type   Param2Type
19750                         DrawType DrawType
19751
19752                         Mesh  string
19753                         Scale float32
19754                         //mt:const uint8(6)
19755                         Tiles        [6]TileDef
19756                         OverlayTiles [6]TileDef
19757                         //mt:const uint8(6)
19758                         SpecialTiles [6]TileDef
19759
19760                         Color   color.NRGBA
19761                         Palette Texture
19762
19763                         Waving       WaveType
19764                         ConnectSides uint8
19765                         ConnectTo    []Content
19766                         InsideTint   color.NRGBA
19767                         Level        uint8 // Must be < 128.
19768
19769                         Translucent bool // Sunlight is scattered and becomes normal light.
19770                         Transparent bool // Sunlight isn't scattered.
19771                         LightSrc    uint8
19772
19773                         GndContent   bool
19774                         Collides     bool
19775                         Pointable    bool
19776                         Diggable     bool
19777                         Climbable    bool
19778                         Replaceable  bool
19779                         OnRightClick bool
19780
19781                         DmgPerSec int32
19782
19783                         LiquidType   LiquidType
19784                         FlowingAlt   string
19785                         SrcAlt       string
19786                         Viscosity    uint8 // 0-7
19787                         LiqRenewable bool
19788                         FlowRange    uint8
19789                         DrownDmg     uint8
19790                         Floodable    bool
19791
19792                         DrawBox, ColBox, SelBox NodeBox
19793
19794                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19795
19796                         LegacyFaceDir bool
19797                         LegacyMounted bool
19798
19799                         DigPredict string
19800
19801                         MaxLvl uint8
19802
19803                         AlphaUse
19804                 }))(obj)).ConnectTo) = make([]Content, local261)
19805                 for local262 := range (*(*(struct {
19806                         Param0 Content
19807
19808                         Name   string
19809                         Groups []Group
19810
19811                         P1Type   Param1Type
19812                         P2Type   Param2Type
19813                         DrawType DrawType
19814
19815                         Mesh  string
19816                         Scale float32
19817                         //mt:const uint8(6)
19818                         Tiles        [6]TileDef
19819                         OverlayTiles [6]TileDef
19820                         //mt:const uint8(6)
19821                         SpecialTiles [6]TileDef
19822
19823                         Color   color.NRGBA
19824                         Palette Texture
19825
19826                         Waving       WaveType
19827                         ConnectSides uint8
19828                         ConnectTo    []Content
19829                         InsideTint   color.NRGBA
19830                         Level        uint8 // Must be < 128.
19831
19832                         Translucent bool // Sunlight is scattered and becomes normal light.
19833                         Transparent bool // Sunlight isn't scattered.
19834                         LightSrc    uint8
19835
19836                         GndContent   bool
19837                         Collides     bool
19838                         Pointable    bool
19839                         Diggable     bool
19840                         Climbable    bool
19841                         Replaceable  bool
19842                         OnRightClick bool
19843
19844                         DmgPerSec int32
19845
19846                         LiquidType   LiquidType
19847                         FlowingAlt   string
19848                         SrcAlt       string
19849                         Viscosity    uint8 // 0-7
19850                         LiqRenewable bool
19851                         FlowRange    uint8
19852                         DrownDmg     uint8
19853                         Floodable    bool
19854
19855                         DrawBox, ColBox, SelBox NodeBox
19856
19857                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19858
19859                         LegacyFaceDir bool
19860                         LegacyMounted bool
19861
19862                         DigPredict string
19863
19864                         MaxLvl uint8
19865
19866                         AlphaUse
19867                 }))(obj)).ConnectTo {
19868                         if err := pcall(func() {
19869                                 (((*(*(struct {
19870                                         Param0 Content
19871
19872                                         Name   string
19873                                         Groups []Group
19874
19875                                         P1Type   Param1Type
19876                                         P2Type   Param2Type
19877                                         DrawType DrawType
19878
19879                                         Mesh  string
19880                                         Scale float32
19881                                         //mt:const uint8(6)
19882                                         Tiles        [6]TileDef
19883                                         OverlayTiles [6]TileDef
19884                                         //mt:const uint8(6)
19885                                         SpecialTiles [6]TileDef
19886
19887                                         Color   color.NRGBA
19888                                         Palette Texture
19889
19890                                         Waving       WaveType
19891                                         ConnectSides uint8
19892                                         ConnectTo    []Content
19893                                         InsideTint   color.NRGBA
19894                                         Level        uint8 // Must be < 128.
19895
19896                                         Translucent bool // Sunlight is scattered and becomes normal light.
19897                                         Transparent bool // Sunlight isn't scattered.
19898                                         LightSrc    uint8
19899
19900                                         GndContent   bool
19901                                         Collides     bool
19902                                         Pointable    bool
19903                                         Diggable     bool
19904                                         Climbable    bool
19905                                         Replaceable  bool
19906                                         OnRightClick bool
19907
19908                                         DmgPerSec int32
19909
19910                                         LiquidType   LiquidType
19911                                         FlowingAlt   string
19912                                         SrcAlt       string
19913                                         Viscosity    uint8 // 0-7
19914                                         LiqRenewable bool
19915                                         FlowRange    uint8
19916                                         DrownDmg     uint8
19917                                         Floodable    bool
19918
19919                                         DrawBox, ColBox, SelBox NodeBox
19920
19921                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19922
19923                                         LegacyFaceDir bool
19924                                         LegacyMounted bool
19925
19926                                         DigPredict string
19927
19928                                         MaxLvl uint8
19929
19930                                         AlphaUse
19931                                 }))(obj)).ConnectTo)[local262]).deserialize(r)
19932                         }); err != nil {
19933                                 if err == io.EOF {
19934                                         chk(io.EOF)
19935                                 }
19936                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
19937                         }
19938                 }
19939                 {
19940                         p := &(*(*(struct {
19941                                 Param0 Content
19942
19943                                 Name   string
19944                                 Groups []Group
19945
19946                                 P1Type   Param1Type
19947                                 P2Type   Param2Type
19948                                 DrawType DrawType
19949
19950                                 Mesh  string
19951                                 Scale float32
19952                                 //mt:const uint8(6)
19953                                 Tiles        [6]TileDef
19954                                 OverlayTiles [6]TileDef
19955                                 //mt:const uint8(6)
19956                                 SpecialTiles [6]TileDef
19957
19958                                 Color   color.NRGBA
19959                                 Palette Texture
19960
19961                                 Waving       WaveType
19962                                 ConnectSides uint8
19963                                 ConnectTo    []Content
19964                                 InsideTint   color.NRGBA
19965                                 Level        uint8 // Must be < 128.
19966
19967                                 Translucent bool // Sunlight is scattered and becomes normal light.
19968                                 Transparent bool // Sunlight isn't scattered.
19969                                 LightSrc    uint8
19970
19971                                 GndContent   bool
19972                                 Collides     bool
19973                                 Pointable    bool
19974                                 Diggable     bool
19975                                 Climbable    bool
19976                                 Replaceable  bool
19977                                 OnRightClick bool
19978
19979                                 DmgPerSec int32
19980
19981                                 LiquidType   LiquidType
19982                                 FlowingAlt   string
19983                                 SrcAlt       string
19984                                 Viscosity    uint8 // 0-7
19985                                 LiqRenewable bool
19986                                 FlowRange    uint8
19987                                 DrownDmg     uint8
19988                                 Floodable    bool
19989
19990                                 DrawBox, ColBox, SelBox NodeBox
19991
19992                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19993
19994                                 LegacyFaceDir bool
19995                                 LegacyMounted bool
19996
19997                                 DigPredict string
19998
19999                                 MaxLvl uint8
20000
20001                                 AlphaUse
20002                         }))(obj)).InsideTint
20003                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20004                 }
20005                 {
20006                         p := &(*(*(struct {
20007                                 Param0 Content
20008
20009                                 Name   string
20010                                 Groups []Group
20011
20012                                 P1Type   Param1Type
20013                                 P2Type   Param2Type
20014                                 DrawType DrawType
20015
20016                                 Mesh  string
20017                                 Scale float32
20018                                 //mt:const uint8(6)
20019                                 Tiles        [6]TileDef
20020                                 OverlayTiles [6]TileDef
20021                                 //mt:const uint8(6)
20022                                 SpecialTiles [6]TileDef
20023
20024                                 Color   color.NRGBA
20025                                 Palette Texture
20026
20027                                 Waving       WaveType
20028                                 ConnectSides uint8
20029                                 ConnectTo    []Content
20030                                 InsideTint   color.NRGBA
20031                                 Level        uint8 // Must be < 128.
20032
20033                                 Translucent bool // Sunlight is scattered and becomes normal light.
20034                                 Transparent bool // Sunlight isn't scattered.
20035                                 LightSrc    uint8
20036
20037                                 GndContent   bool
20038                                 Collides     bool
20039                                 Pointable    bool
20040                                 Diggable     bool
20041                                 Climbable    bool
20042                                 Replaceable  bool
20043                                 OnRightClick bool
20044
20045                                 DmgPerSec int32
20046
20047                                 LiquidType   LiquidType
20048                                 FlowingAlt   string
20049                                 SrcAlt       string
20050                                 Viscosity    uint8 // 0-7
20051                                 LiqRenewable bool
20052                                 FlowRange    uint8
20053                                 DrownDmg     uint8
20054                                 Floodable    bool
20055
20056                                 DrawBox, ColBox, SelBox NodeBox
20057
20058                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20059
20060                                 LegacyFaceDir bool
20061                                 LegacyMounted bool
20062
20063                                 DigPredict string
20064
20065                                 MaxLvl uint8
20066
20067                                 AlphaUse
20068                         }))(obj)).Level
20069                         *p = read8(r)
20070                 }
20071                 {
20072                         p := &(*(*(struct {
20073                                 Param0 Content
20074
20075                                 Name   string
20076                                 Groups []Group
20077
20078                                 P1Type   Param1Type
20079                                 P2Type   Param2Type
20080                                 DrawType DrawType
20081
20082                                 Mesh  string
20083                                 Scale float32
20084                                 //mt:const uint8(6)
20085                                 Tiles        [6]TileDef
20086                                 OverlayTiles [6]TileDef
20087                                 //mt:const uint8(6)
20088                                 SpecialTiles [6]TileDef
20089
20090                                 Color   color.NRGBA
20091                                 Palette Texture
20092
20093                                 Waving       WaveType
20094                                 ConnectSides uint8
20095                                 ConnectTo    []Content
20096                                 InsideTint   color.NRGBA
20097                                 Level        uint8 // Must be < 128.
20098
20099                                 Translucent bool // Sunlight is scattered and becomes normal light.
20100                                 Transparent bool // Sunlight isn't scattered.
20101                                 LightSrc    uint8
20102
20103                                 GndContent   bool
20104                                 Collides     bool
20105                                 Pointable    bool
20106                                 Diggable     bool
20107                                 Climbable    bool
20108                                 Replaceable  bool
20109                                 OnRightClick bool
20110
20111                                 DmgPerSec int32
20112
20113                                 LiquidType   LiquidType
20114                                 FlowingAlt   string
20115                                 SrcAlt       string
20116                                 Viscosity    uint8 // 0-7
20117                                 LiqRenewable bool
20118                                 FlowRange    uint8
20119                                 DrownDmg     uint8
20120                                 Floodable    bool
20121
20122                                 DrawBox, ColBox, SelBox NodeBox
20123
20124                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20125
20126                                 LegacyFaceDir bool
20127                                 LegacyMounted bool
20128
20129                                 DigPredict string
20130
20131                                 MaxLvl uint8
20132
20133                                 AlphaUse
20134                         }))(obj)).Translucent
20135                         switch n := read8(r); n {
20136                         case 0:
20137                                 *p = false
20138                         case 1:
20139                                 *p = true
20140                         default:
20141                                 chk(fmt.Errorf("invalid bool: %d", n))
20142                         }
20143                 }
20144                 {
20145                         p := &(*(*(struct {
20146                                 Param0 Content
20147
20148                                 Name   string
20149                                 Groups []Group
20150
20151                                 P1Type   Param1Type
20152                                 P2Type   Param2Type
20153                                 DrawType DrawType
20154
20155                                 Mesh  string
20156                                 Scale float32
20157                                 //mt:const uint8(6)
20158                                 Tiles        [6]TileDef
20159                                 OverlayTiles [6]TileDef
20160                                 //mt:const uint8(6)
20161                                 SpecialTiles [6]TileDef
20162
20163                                 Color   color.NRGBA
20164                                 Palette Texture
20165
20166                                 Waving       WaveType
20167                                 ConnectSides uint8
20168                                 ConnectTo    []Content
20169                                 InsideTint   color.NRGBA
20170                                 Level        uint8 // Must be < 128.
20171
20172                                 Translucent bool // Sunlight is scattered and becomes normal light.
20173                                 Transparent bool // Sunlight isn't scattered.
20174                                 LightSrc    uint8
20175
20176                                 GndContent   bool
20177                                 Collides     bool
20178                                 Pointable    bool
20179                                 Diggable     bool
20180                                 Climbable    bool
20181                                 Replaceable  bool
20182                                 OnRightClick bool
20183
20184                                 DmgPerSec int32
20185
20186                                 LiquidType   LiquidType
20187                                 FlowingAlt   string
20188                                 SrcAlt       string
20189                                 Viscosity    uint8 // 0-7
20190                                 LiqRenewable bool
20191                                 FlowRange    uint8
20192                                 DrownDmg     uint8
20193                                 Floodable    bool
20194
20195                                 DrawBox, ColBox, SelBox NodeBox
20196
20197                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20198
20199                                 LegacyFaceDir bool
20200                                 LegacyMounted bool
20201
20202                                 DigPredict string
20203
20204                                 MaxLvl uint8
20205
20206                                 AlphaUse
20207                         }))(obj)).Transparent
20208                         switch n := read8(r); n {
20209                         case 0:
20210                                 *p = false
20211                         case 1:
20212                                 *p = true
20213                         default:
20214                                 chk(fmt.Errorf("invalid bool: %d", n))
20215                         }
20216                 }
20217                 {
20218                         p := &(*(*(struct {
20219                                 Param0 Content
20220
20221                                 Name   string
20222                                 Groups []Group
20223
20224                                 P1Type   Param1Type
20225                                 P2Type   Param2Type
20226                                 DrawType DrawType
20227
20228                                 Mesh  string
20229                                 Scale float32
20230                                 //mt:const uint8(6)
20231                                 Tiles        [6]TileDef
20232                                 OverlayTiles [6]TileDef
20233                                 //mt:const uint8(6)
20234                                 SpecialTiles [6]TileDef
20235
20236                                 Color   color.NRGBA
20237                                 Palette Texture
20238
20239                                 Waving       WaveType
20240                                 ConnectSides uint8
20241                                 ConnectTo    []Content
20242                                 InsideTint   color.NRGBA
20243                                 Level        uint8 // Must be < 128.
20244
20245                                 Translucent bool // Sunlight is scattered and becomes normal light.
20246                                 Transparent bool // Sunlight isn't scattered.
20247                                 LightSrc    uint8
20248
20249                                 GndContent   bool
20250                                 Collides     bool
20251                                 Pointable    bool
20252                                 Diggable     bool
20253                                 Climbable    bool
20254                                 Replaceable  bool
20255                                 OnRightClick bool
20256
20257                                 DmgPerSec int32
20258
20259                                 LiquidType   LiquidType
20260                                 FlowingAlt   string
20261                                 SrcAlt       string
20262                                 Viscosity    uint8 // 0-7
20263                                 LiqRenewable bool
20264                                 FlowRange    uint8
20265                                 DrownDmg     uint8
20266                                 Floodable    bool
20267
20268                                 DrawBox, ColBox, SelBox NodeBox
20269
20270                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20271
20272                                 LegacyFaceDir bool
20273                                 LegacyMounted bool
20274
20275                                 DigPredict string
20276
20277                                 MaxLvl uint8
20278
20279                                 AlphaUse
20280                         }))(obj)).LightSrc
20281                         *p = read8(r)
20282                 }
20283                 {
20284                         p := &(*(*(struct {
20285                                 Param0 Content
20286
20287                                 Name   string
20288                                 Groups []Group
20289
20290                                 P1Type   Param1Type
20291                                 P2Type   Param2Type
20292                                 DrawType DrawType
20293
20294                                 Mesh  string
20295                                 Scale float32
20296                                 //mt:const uint8(6)
20297                                 Tiles        [6]TileDef
20298                                 OverlayTiles [6]TileDef
20299                                 //mt:const uint8(6)
20300                                 SpecialTiles [6]TileDef
20301
20302                                 Color   color.NRGBA
20303                                 Palette Texture
20304
20305                                 Waving       WaveType
20306                                 ConnectSides uint8
20307                                 ConnectTo    []Content
20308                                 InsideTint   color.NRGBA
20309                                 Level        uint8 // Must be < 128.
20310
20311                                 Translucent bool // Sunlight is scattered and becomes normal light.
20312                                 Transparent bool // Sunlight isn't scattered.
20313                                 LightSrc    uint8
20314
20315                                 GndContent   bool
20316                                 Collides     bool
20317                                 Pointable    bool
20318                                 Diggable     bool
20319                                 Climbable    bool
20320                                 Replaceable  bool
20321                                 OnRightClick bool
20322
20323                                 DmgPerSec int32
20324
20325                                 LiquidType   LiquidType
20326                                 FlowingAlt   string
20327                                 SrcAlt       string
20328                                 Viscosity    uint8 // 0-7
20329                                 LiqRenewable bool
20330                                 FlowRange    uint8
20331                                 DrownDmg     uint8
20332                                 Floodable    bool
20333
20334                                 DrawBox, ColBox, SelBox NodeBox
20335
20336                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20337
20338                                 LegacyFaceDir bool
20339                                 LegacyMounted bool
20340
20341                                 DigPredict string
20342
20343                                 MaxLvl uint8
20344
20345                                 AlphaUse
20346                         }))(obj)).GndContent
20347                         switch n := read8(r); n {
20348                         case 0:
20349                                 *p = false
20350                         case 1:
20351                                 *p = true
20352                         default:
20353                                 chk(fmt.Errorf("invalid bool: %d", n))
20354                         }
20355                 }
20356                 {
20357                         p := &(*(*(struct {
20358                                 Param0 Content
20359
20360                                 Name   string
20361                                 Groups []Group
20362
20363                                 P1Type   Param1Type
20364                                 P2Type   Param2Type
20365                                 DrawType DrawType
20366
20367                                 Mesh  string
20368                                 Scale float32
20369                                 //mt:const uint8(6)
20370                                 Tiles        [6]TileDef
20371                                 OverlayTiles [6]TileDef
20372                                 //mt:const uint8(6)
20373                                 SpecialTiles [6]TileDef
20374
20375                                 Color   color.NRGBA
20376                                 Palette Texture
20377
20378                                 Waving       WaveType
20379                                 ConnectSides uint8
20380                                 ConnectTo    []Content
20381                                 InsideTint   color.NRGBA
20382                                 Level        uint8 // Must be < 128.
20383
20384                                 Translucent bool // Sunlight is scattered and becomes normal light.
20385                                 Transparent bool // Sunlight isn't scattered.
20386                                 LightSrc    uint8
20387
20388                                 GndContent   bool
20389                                 Collides     bool
20390                                 Pointable    bool
20391                                 Diggable     bool
20392                                 Climbable    bool
20393                                 Replaceable  bool
20394                                 OnRightClick bool
20395
20396                                 DmgPerSec int32
20397
20398                                 LiquidType   LiquidType
20399                                 FlowingAlt   string
20400                                 SrcAlt       string
20401                                 Viscosity    uint8 // 0-7
20402                                 LiqRenewable bool
20403                                 FlowRange    uint8
20404                                 DrownDmg     uint8
20405                                 Floodable    bool
20406
20407                                 DrawBox, ColBox, SelBox NodeBox
20408
20409                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20410
20411                                 LegacyFaceDir bool
20412                                 LegacyMounted bool
20413
20414                                 DigPredict string
20415
20416                                 MaxLvl uint8
20417
20418                                 AlphaUse
20419                         }))(obj)).Collides
20420                         switch n := read8(r); n {
20421                         case 0:
20422                                 *p = false
20423                         case 1:
20424                                 *p = true
20425                         default:
20426                                 chk(fmt.Errorf("invalid bool: %d", n))
20427                         }
20428                 }
20429                 {
20430                         p := &(*(*(struct {
20431                                 Param0 Content
20432
20433                                 Name   string
20434                                 Groups []Group
20435
20436                                 P1Type   Param1Type
20437                                 P2Type   Param2Type
20438                                 DrawType DrawType
20439
20440                                 Mesh  string
20441                                 Scale float32
20442                                 //mt:const uint8(6)
20443                                 Tiles        [6]TileDef
20444                                 OverlayTiles [6]TileDef
20445                                 //mt:const uint8(6)
20446                                 SpecialTiles [6]TileDef
20447
20448                                 Color   color.NRGBA
20449                                 Palette Texture
20450
20451                                 Waving       WaveType
20452                                 ConnectSides uint8
20453                                 ConnectTo    []Content
20454                                 InsideTint   color.NRGBA
20455                                 Level        uint8 // Must be < 128.
20456
20457                                 Translucent bool // Sunlight is scattered and becomes normal light.
20458                                 Transparent bool // Sunlight isn't scattered.
20459                                 LightSrc    uint8
20460
20461                                 GndContent   bool
20462                                 Collides     bool
20463                                 Pointable    bool
20464                                 Diggable     bool
20465                                 Climbable    bool
20466                                 Replaceable  bool
20467                                 OnRightClick bool
20468
20469                                 DmgPerSec int32
20470
20471                                 LiquidType   LiquidType
20472                                 FlowingAlt   string
20473                                 SrcAlt       string
20474                                 Viscosity    uint8 // 0-7
20475                                 LiqRenewable bool
20476                                 FlowRange    uint8
20477                                 DrownDmg     uint8
20478                                 Floodable    bool
20479
20480                                 DrawBox, ColBox, SelBox NodeBox
20481
20482                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20483
20484                                 LegacyFaceDir bool
20485                                 LegacyMounted bool
20486
20487                                 DigPredict string
20488
20489                                 MaxLvl uint8
20490
20491                                 AlphaUse
20492                         }))(obj)).Pointable
20493                         switch n := read8(r); n {
20494                         case 0:
20495                                 *p = false
20496                         case 1:
20497                                 *p = true
20498                         default:
20499                                 chk(fmt.Errorf("invalid bool: %d", n))
20500                         }
20501                 }
20502                 {
20503                         p := &(*(*(struct {
20504                                 Param0 Content
20505
20506                                 Name   string
20507                                 Groups []Group
20508
20509                                 P1Type   Param1Type
20510                                 P2Type   Param2Type
20511                                 DrawType DrawType
20512
20513                                 Mesh  string
20514                                 Scale float32
20515                                 //mt:const uint8(6)
20516                                 Tiles        [6]TileDef
20517                                 OverlayTiles [6]TileDef
20518                                 //mt:const uint8(6)
20519                                 SpecialTiles [6]TileDef
20520
20521                                 Color   color.NRGBA
20522                                 Palette Texture
20523
20524                                 Waving       WaveType
20525                                 ConnectSides uint8
20526                                 ConnectTo    []Content
20527                                 InsideTint   color.NRGBA
20528                                 Level        uint8 // Must be < 128.
20529
20530                                 Translucent bool // Sunlight is scattered and becomes normal light.
20531                                 Transparent bool // Sunlight isn't scattered.
20532                                 LightSrc    uint8
20533
20534                                 GndContent   bool
20535                                 Collides     bool
20536                                 Pointable    bool
20537                                 Diggable     bool
20538                                 Climbable    bool
20539                                 Replaceable  bool
20540                                 OnRightClick bool
20541
20542                                 DmgPerSec int32
20543
20544                                 LiquidType   LiquidType
20545                                 FlowingAlt   string
20546                                 SrcAlt       string
20547                                 Viscosity    uint8 // 0-7
20548                                 LiqRenewable bool
20549                                 FlowRange    uint8
20550                                 DrownDmg     uint8
20551                                 Floodable    bool
20552
20553                                 DrawBox, ColBox, SelBox NodeBox
20554
20555                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20556
20557                                 LegacyFaceDir bool
20558                                 LegacyMounted bool
20559
20560                                 DigPredict string
20561
20562                                 MaxLvl uint8
20563
20564                                 AlphaUse
20565                         }))(obj)).Diggable
20566                         switch n := read8(r); n {
20567                         case 0:
20568                                 *p = false
20569                         case 1:
20570                                 *p = true
20571                         default:
20572                                 chk(fmt.Errorf("invalid bool: %d", n))
20573                         }
20574                 }
20575                 {
20576                         p := &(*(*(struct {
20577                                 Param0 Content
20578
20579                                 Name   string
20580                                 Groups []Group
20581
20582                                 P1Type   Param1Type
20583                                 P2Type   Param2Type
20584                                 DrawType DrawType
20585
20586                                 Mesh  string
20587                                 Scale float32
20588                                 //mt:const uint8(6)
20589                                 Tiles        [6]TileDef
20590                                 OverlayTiles [6]TileDef
20591                                 //mt:const uint8(6)
20592                                 SpecialTiles [6]TileDef
20593
20594                                 Color   color.NRGBA
20595                                 Palette Texture
20596
20597                                 Waving       WaveType
20598                                 ConnectSides uint8
20599                                 ConnectTo    []Content
20600                                 InsideTint   color.NRGBA
20601                                 Level        uint8 // Must be < 128.
20602
20603                                 Translucent bool // Sunlight is scattered and becomes normal light.
20604                                 Transparent bool // Sunlight isn't scattered.
20605                                 LightSrc    uint8
20606
20607                                 GndContent   bool
20608                                 Collides     bool
20609                                 Pointable    bool
20610                                 Diggable     bool
20611                                 Climbable    bool
20612                                 Replaceable  bool
20613                                 OnRightClick bool
20614
20615                                 DmgPerSec int32
20616
20617                                 LiquidType   LiquidType
20618                                 FlowingAlt   string
20619                                 SrcAlt       string
20620                                 Viscosity    uint8 // 0-7
20621                                 LiqRenewable bool
20622                                 FlowRange    uint8
20623                                 DrownDmg     uint8
20624                                 Floodable    bool
20625
20626                                 DrawBox, ColBox, SelBox NodeBox
20627
20628                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20629
20630                                 LegacyFaceDir bool
20631                                 LegacyMounted bool
20632
20633                                 DigPredict string
20634
20635                                 MaxLvl uint8
20636
20637                                 AlphaUse
20638                         }))(obj)).Climbable
20639                         switch n := read8(r); n {
20640                         case 0:
20641                                 *p = false
20642                         case 1:
20643                                 *p = true
20644                         default:
20645                                 chk(fmt.Errorf("invalid bool: %d", n))
20646                         }
20647                 }
20648                 {
20649                         p := &(*(*(struct {
20650                                 Param0 Content
20651
20652                                 Name   string
20653                                 Groups []Group
20654
20655                                 P1Type   Param1Type
20656                                 P2Type   Param2Type
20657                                 DrawType DrawType
20658
20659                                 Mesh  string
20660                                 Scale float32
20661                                 //mt:const uint8(6)
20662                                 Tiles        [6]TileDef
20663                                 OverlayTiles [6]TileDef
20664                                 //mt:const uint8(6)
20665                                 SpecialTiles [6]TileDef
20666
20667                                 Color   color.NRGBA
20668                                 Palette Texture
20669
20670                                 Waving       WaveType
20671                                 ConnectSides uint8
20672                                 ConnectTo    []Content
20673                                 InsideTint   color.NRGBA
20674                                 Level        uint8 // Must be < 128.
20675
20676                                 Translucent bool // Sunlight is scattered and becomes normal light.
20677                                 Transparent bool // Sunlight isn't scattered.
20678                                 LightSrc    uint8
20679
20680                                 GndContent   bool
20681                                 Collides     bool
20682                                 Pointable    bool
20683                                 Diggable     bool
20684                                 Climbable    bool
20685                                 Replaceable  bool
20686                                 OnRightClick bool
20687
20688                                 DmgPerSec int32
20689
20690                                 LiquidType   LiquidType
20691                                 FlowingAlt   string
20692                                 SrcAlt       string
20693                                 Viscosity    uint8 // 0-7
20694                                 LiqRenewable bool
20695                                 FlowRange    uint8
20696                                 DrownDmg     uint8
20697                                 Floodable    bool
20698
20699                                 DrawBox, ColBox, SelBox NodeBox
20700
20701                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20702
20703                                 LegacyFaceDir bool
20704                                 LegacyMounted bool
20705
20706                                 DigPredict string
20707
20708                                 MaxLvl uint8
20709
20710                                 AlphaUse
20711                         }))(obj)).Replaceable
20712                         switch n := read8(r); n {
20713                         case 0:
20714                                 *p = false
20715                         case 1:
20716                                 *p = true
20717                         default:
20718                                 chk(fmt.Errorf("invalid bool: %d", n))
20719                         }
20720                 }
20721                 {
20722                         p := &(*(*(struct {
20723                                 Param0 Content
20724
20725                                 Name   string
20726                                 Groups []Group
20727
20728                                 P1Type   Param1Type
20729                                 P2Type   Param2Type
20730                                 DrawType DrawType
20731
20732                                 Mesh  string
20733                                 Scale float32
20734                                 //mt:const uint8(6)
20735                                 Tiles        [6]TileDef
20736                                 OverlayTiles [6]TileDef
20737                                 //mt:const uint8(6)
20738                                 SpecialTiles [6]TileDef
20739
20740                                 Color   color.NRGBA
20741                                 Palette Texture
20742
20743                                 Waving       WaveType
20744                                 ConnectSides uint8
20745                                 ConnectTo    []Content
20746                                 InsideTint   color.NRGBA
20747                                 Level        uint8 // Must be < 128.
20748
20749                                 Translucent bool // Sunlight is scattered and becomes normal light.
20750                                 Transparent bool // Sunlight isn't scattered.
20751                                 LightSrc    uint8
20752
20753                                 GndContent   bool
20754                                 Collides     bool
20755                                 Pointable    bool
20756                                 Diggable     bool
20757                                 Climbable    bool
20758                                 Replaceable  bool
20759                                 OnRightClick bool
20760
20761                                 DmgPerSec int32
20762
20763                                 LiquidType   LiquidType
20764                                 FlowingAlt   string
20765                                 SrcAlt       string
20766                                 Viscosity    uint8 // 0-7
20767                                 LiqRenewable bool
20768                                 FlowRange    uint8
20769                                 DrownDmg     uint8
20770                                 Floodable    bool
20771
20772                                 DrawBox, ColBox, SelBox NodeBox
20773
20774                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20775
20776                                 LegacyFaceDir bool
20777                                 LegacyMounted bool
20778
20779                                 DigPredict string
20780
20781                                 MaxLvl uint8
20782
20783                                 AlphaUse
20784                         }))(obj)).OnRightClick
20785                         switch n := read8(r); n {
20786                         case 0:
20787                                 *p = false
20788                         case 1:
20789                                 *p = true
20790                         default:
20791                                 chk(fmt.Errorf("invalid bool: %d", n))
20792                         }
20793                 }
20794                 {
20795                         p := &(*(*(struct {
20796                                 Param0 Content
20797
20798                                 Name   string
20799                                 Groups []Group
20800
20801                                 P1Type   Param1Type
20802                                 P2Type   Param2Type
20803                                 DrawType DrawType
20804
20805                                 Mesh  string
20806                                 Scale float32
20807                                 //mt:const uint8(6)
20808                                 Tiles        [6]TileDef
20809                                 OverlayTiles [6]TileDef
20810                                 //mt:const uint8(6)
20811                                 SpecialTiles [6]TileDef
20812
20813                                 Color   color.NRGBA
20814                                 Palette Texture
20815
20816                                 Waving       WaveType
20817                                 ConnectSides uint8
20818                                 ConnectTo    []Content
20819                                 InsideTint   color.NRGBA
20820                                 Level        uint8 // Must be < 128.
20821
20822                                 Translucent bool // Sunlight is scattered and becomes normal light.
20823                                 Transparent bool // Sunlight isn't scattered.
20824                                 LightSrc    uint8
20825
20826                                 GndContent   bool
20827                                 Collides     bool
20828                                 Pointable    bool
20829                                 Diggable     bool
20830                                 Climbable    bool
20831                                 Replaceable  bool
20832                                 OnRightClick bool
20833
20834                                 DmgPerSec int32
20835
20836                                 LiquidType   LiquidType
20837                                 FlowingAlt   string
20838                                 SrcAlt       string
20839                                 Viscosity    uint8 // 0-7
20840                                 LiqRenewable bool
20841                                 FlowRange    uint8
20842                                 DrownDmg     uint8
20843                                 Floodable    bool
20844
20845                                 DrawBox, ColBox, SelBox NodeBox
20846
20847                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20848
20849                                 LegacyFaceDir bool
20850                                 LegacyMounted bool
20851
20852                                 DigPredict string
20853
20854                                 MaxLvl uint8
20855
20856                                 AlphaUse
20857                         }))(obj)).DmgPerSec
20858                         *p = int32(read32(r))
20859                 }
20860                 if err := pcall(func() {
20861                         ((*(*(struct {
20862                                 Param0 Content
20863
20864                                 Name   string
20865                                 Groups []Group
20866
20867                                 P1Type   Param1Type
20868                                 P2Type   Param2Type
20869                                 DrawType DrawType
20870
20871                                 Mesh  string
20872                                 Scale float32
20873                                 //mt:const uint8(6)
20874                                 Tiles        [6]TileDef
20875                                 OverlayTiles [6]TileDef
20876                                 //mt:const uint8(6)
20877                                 SpecialTiles [6]TileDef
20878
20879                                 Color   color.NRGBA
20880                                 Palette Texture
20881
20882                                 Waving       WaveType
20883                                 ConnectSides uint8
20884                                 ConnectTo    []Content
20885                                 InsideTint   color.NRGBA
20886                                 Level        uint8 // Must be < 128.
20887
20888                                 Translucent bool // Sunlight is scattered and becomes normal light.
20889                                 Transparent bool // Sunlight isn't scattered.
20890                                 LightSrc    uint8
20891
20892                                 GndContent   bool
20893                                 Collides     bool
20894                                 Pointable    bool
20895                                 Diggable     bool
20896                                 Climbable    bool
20897                                 Replaceable  bool
20898                                 OnRightClick bool
20899
20900                                 DmgPerSec int32
20901
20902                                 LiquidType   LiquidType
20903                                 FlowingAlt   string
20904                                 SrcAlt       string
20905                                 Viscosity    uint8 // 0-7
20906                                 LiqRenewable bool
20907                                 FlowRange    uint8
20908                                 DrownDmg     uint8
20909                                 Floodable    bool
20910
20911                                 DrawBox, ColBox, SelBox NodeBox
20912
20913                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20914
20915                                 LegacyFaceDir bool
20916                                 LegacyMounted bool
20917
20918                                 DigPredict string
20919
20920                                 MaxLvl uint8
20921
20922                                 AlphaUse
20923                         }))(obj)).LiquidType).deserialize(r)
20924                 }); err != nil {
20925                         if err == io.EOF {
20926                                 chk(io.EOF)
20927                         }
20928                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LiquidType", err))
20929                 }
20930                 var local263 []uint8
20931                 var local264 uint16
20932                 {
20933                         p := &local264
20934                         *p = read16(r)
20935                 }
20936                 (local263) = make([]uint8, local264)
20937                 {
20938                         _, err := io.ReadFull(r, (local263)[:])
20939                         chk(err)
20940                 }
20941                 ((*(*(struct {
20942                         Param0 Content
20943
20944                         Name   string
20945                         Groups []Group
20946
20947                         P1Type   Param1Type
20948                         P2Type   Param2Type
20949                         DrawType DrawType
20950
20951                         Mesh  string
20952                         Scale float32
20953                         //mt:const uint8(6)
20954                         Tiles        [6]TileDef
20955                         OverlayTiles [6]TileDef
20956                         //mt:const uint8(6)
20957                         SpecialTiles [6]TileDef
20958
20959                         Color   color.NRGBA
20960                         Palette Texture
20961
20962                         Waving       WaveType
20963                         ConnectSides uint8
20964                         ConnectTo    []Content
20965                         InsideTint   color.NRGBA
20966                         Level        uint8 // Must be < 128.
20967
20968                         Translucent bool // Sunlight is scattered and becomes normal light.
20969                         Transparent bool // Sunlight isn't scattered.
20970                         LightSrc    uint8
20971
20972                         GndContent   bool
20973                         Collides     bool
20974                         Pointable    bool
20975                         Diggable     bool
20976                         Climbable    bool
20977                         Replaceable  bool
20978                         OnRightClick bool
20979
20980                         DmgPerSec int32
20981
20982                         LiquidType   LiquidType
20983                         FlowingAlt   string
20984                         SrcAlt       string
20985                         Viscosity    uint8 // 0-7
20986                         LiqRenewable bool
20987                         FlowRange    uint8
20988                         DrownDmg     uint8
20989                         Floodable    bool
20990
20991                         DrawBox, ColBox, SelBox NodeBox
20992
20993                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20994
20995                         LegacyFaceDir bool
20996                         LegacyMounted bool
20997
20998                         DigPredict string
20999
21000                         MaxLvl uint8
21001
21002                         AlphaUse
21003                 }))(obj)).FlowingAlt) = string(local263)
21004                 var local265 []uint8
21005                 var local266 uint16
21006                 {
21007                         p := &local266
21008                         *p = read16(r)
21009                 }
21010                 (local265) = make([]uint8, local266)
21011                 {
21012                         _, err := io.ReadFull(r, (local265)[:])
21013                         chk(err)
21014                 }
21015                 ((*(*(struct {
21016                         Param0 Content
21017
21018                         Name   string
21019                         Groups []Group
21020
21021                         P1Type   Param1Type
21022                         P2Type   Param2Type
21023                         DrawType DrawType
21024
21025                         Mesh  string
21026                         Scale float32
21027                         //mt:const uint8(6)
21028                         Tiles        [6]TileDef
21029                         OverlayTiles [6]TileDef
21030                         //mt:const uint8(6)
21031                         SpecialTiles [6]TileDef
21032
21033                         Color   color.NRGBA
21034                         Palette Texture
21035
21036                         Waving       WaveType
21037                         ConnectSides uint8
21038                         ConnectTo    []Content
21039                         InsideTint   color.NRGBA
21040                         Level        uint8 // Must be < 128.
21041
21042                         Translucent bool // Sunlight is scattered and becomes normal light.
21043                         Transparent bool // Sunlight isn't scattered.
21044                         LightSrc    uint8
21045
21046                         GndContent   bool
21047                         Collides     bool
21048                         Pointable    bool
21049                         Diggable     bool
21050                         Climbable    bool
21051                         Replaceable  bool
21052                         OnRightClick bool
21053
21054                         DmgPerSec int32
21055
21056                         LiquidType   LiquidType
21057                         FlowingAlt   string
21058                         SrcAlt       string
21059                         Viscosity    uint8 // 0-7
21060                         LiqRenewable bool
21061                         FlowRange    uint8
21062                         DrownDmg     uint8
21063                         Floodable    bool
21064
21065                         DrawBox, ColBox, SelBox NodeBox
21066
21067                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21068
21069                         LegacyFaceDir bool
21070                         LegacyMounted bool
21071
21072                         DigPredict string
21073
21074                         MaxLvl uint8
21075
21076                         AlphaUse
21077                 }))(obj)).SrcAlt) = string(local265)
21078                 {
21079                         p := &(*(*(struct {
21080                                 Param0 Content
21081
21082                                 Name   string
21083                                 Groups []Group
21084
21085                                 P1Type   Param1Type
21086                                 P2Type   Param2Type
21087                                 DrawType DrawType
21088
21089                                 Mesh  string
21090                                 Scale float32
21091                                 //mt:const uint8(6)
21092                                 Tiles        [6]TileDef
21093                                 OverlayTiles [6]TileDef
21094                                 //mt:const uint8(6)
21095                                 SpecialTiles [6]TileDef
21096
21097                                 Color   color.NRGBA
21098                                 Palette Texture
21099
21100                                 Waving       WaveType
21101                                 ConnectSides uint8
21102                                 ConnectTo    []Content
21103                                 InsideTint   color.NRGBA
21104                                 Level        uint8 // Must be < 128.
21105
21106                                 Translucent bool // Sunlight is scattered and becomes normal light.
21107                                 Transparent bool // Sunlight isn't scattered.
21108                                 LightSrc    uint8
21109
21110                                 GndContent   bool
21111                                 Collides     bool
21112                                 Pointable    bool
21113                                 Diggable     bool
21114                                 Climbable    bool
21115                                 Replaceable  bool
21116                                 OnRightClick bool
21117
21118                                 DmgPerSec int32
21119
21120                                 LiquidType   LiquidType
21121                                 FlowingAlt   string
21122                                 SrcAlt       string
21123                                 Viscosity    uint8 // 0-7
21124                                 LiqRenewable bool
21125                                 FlowRange    uint8
21126                                 DrownDmg     uint8
21127                                 Floodable    bool
21128
21129                                 DrawBox, ColBox, SelBox NodeBox
21130
21131                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21132
21133                                 LegacyFaceDir bool
21134                                 LegacyMounted bool
21135
21136                                 DigPredict string
21137
21138                                 MaxLvl uint8
21139
21140                                 AlphaUse
21141                         }))(obj)).Viscosity
21142                         *p = read8(r)
21143                 }
21144                 {
21145                         p := &(*(*(struct {
21146                                 Param0 Content
21147
21148                                 Name   string
21149                                 Groups []Group
21150
21151                                 P1Type   Param1Type
21152                                 P2Type   Param2Type
21153                                 DrawType DrawType
21154
21155                                 Mesh  string
21156                                 Scale float32
21157                                 //mt:const uint8(6)
21158                                 Tiles        [6]TileDef
21159                                 OverlayTiles [6]TileDef
21160                                 //mt:const uint8(6)
21161                                 SpecialTiles [6]TileDef
21162
21163                                 Color   color.NRGBA
21164                                 Palette Texture
21165
21166                                 Waving       WaveType
21167                                 ConnectSides uint8
21168                                 ConnectTo    []Content
21169                                 InsideTint   color.NRGBA
21170                                 Level        uint8 // Must be < 128.
21171
21172                                 Translucent bool // Sunlight is scattered and becomes normal light.
21173                                 Transparent bool // Sunlight isn't scattered.
21174                                 LightSrc    uint8
21175
21176                                 GndContent   bool
21177                                 Collides     bool
21178                                 Pointable    bool
21179                                 Diggable     bool
21180                                 Climbable    bool
21181                                 Replaceable  bool
21182                                 OnRightClick bool
21183
21184                                 DmgPerSec int32
21185
21186                                 LiquidType   LiquidType
21187                                 FlowingAlt   string
21188                                 SrcAlt       string
21189                                 Viscosity    uint8 // 0-7
21190                                 LiqRenewable bool
21191                                 FlowRange    uint8
21192                                 DrownDmg     uint8
21193                                 Floodable    bool
21194
21195                                 DrawBox, ColBox, SelBox NodeBox
21196
21197                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21198
21199                                 LegacyFaceDir bool
21200                                 LegacyMounted bool
21201
21202                                 DigPredict string
21203
21204                                 MaxLvl uint8
21205
21206                                 AlphaUse
21207                         }))(obj)).LiqRenewable
21208                         switch n := read8(r); n {
21209                         case 0:
21210                                 *p = false
21211                         case 1:
21212                                 *p = true
21213                         default:
21214                                 chk(fmt.Errorf("invalid bool: %d", n))
21215                         }
21216                 }
21217                 {
21218                         p := &(*(*(struct {
21219                                 Param0 Content
21220
21221                                 Name   string
21222                                 Groups []Group
21223
21224                                 P1Type   Param1Type
21225                                 P2Type   Param2Type
21226                                 DrawType DrawType
21227
21228                                 Mesh  string
21229                                 Scale float32
21230                                 //mt:const uint8(6)
21231                                 Tiles        [6]TileDef
21232                                 OverlayTiles [6]TileDef
21233                                 //mt:const uint8(6)
21234                                 SpecialTiles [6]TileDef
21235
21236                                 Color   color.NRGBA
21237                                 Palette Texture
21238
21239                                 Waving       WaveType
21240                                 ConnectSides uint8
21241                                 ConnectTo    []Content
21242                                 InsideTint   color.NRGBA
21243                                 Level        uint8 // Must be < 128.
21244
21245                                 Translucent bool // Sunlight is scattered and becomes normal light.
21246                                 Transparent bool // Sunlight isn't scattered.
21247                                 LightSrc    uint8
21248
21249                                 GndContent   bool
21250                                 Collides     bool
21251                                 Pointable    bool
21252                                 Diggable     bool
21253                                 Climbable    bool
21254                                 Replaceable  bool
21255                                 OnRightClick bool
21256
21257                                 DmgPerSec int32
21258
21259                                 LiquidType   LiquidType
21260                                 FlowingAlt   string
21261                                 SrcAlt       string
21262                                 Viscosity    uint8 // 0-7
21263                                 LiqRenewable bool
21264                                 FlowRange    uint8
21265                                 DrownDmg     uint8
21266                                 Floodable    bool
21267
21268                                 DrawBox, ColBox, SelBox NodeBox
21269
21270                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21271
21272                                 LegacyFaceDir bool
21273                                 LegacyMounted bool
21274
21275                                 DigPredict string
21276
21277                                 MaxLvl uint8
21278
21279                                 AlphaUse
21280                         }))(obj)).FlowRange
21281                         *p = read8(r)
21282                 }
21283                 {
21284                         p := &(*(*(struct {
21285                                 Param0 Content
21286
21287                                 Name   string
21288                                 Groups []Group
21289
21290                                 P1Type   Param1Type
21291                                 P2Type   Param2Type
21292                                 DrawType DrawType
21293
21294                                 Mesh  string
21295                                 Scale float32
21296                                 //mt:const uint8(6)
21297                                 Tiles        [6]TileDef
21298                                 OverlayTiles [6]TileDef
21299                                 //mt:const uint8(6)
21300                                 SpecialTiles [6]TileDef
21301
21302                                 Color   color.NRGBA
21303                                 Palette Texture
21304
21305                                 Waving       WaveType
21306                                 ConnectSides uint8
21307                                 ConnectTo    []Content
21308                                 InsideTint   color.NRGBA
21309                                 Level        uint8 // Must be < 128.
21310
21311                                 Translucent bool // Sunlight is scattered and becomes normal light.
21312                                 Transparent bool // Sunlight isn't scattered.
21313                                 LightSrc    uint8
21314
21315                                 GndContent   bool
21316                                 Collides     bool
21317                                 Pointable    bool
21318                                 Diggable     bool
21319                                 Climbable    bool
21320                                 Replaceable  bool
21321                                 OnRightClick bool
21322
21323                                 DmgPerSec int32
21324
21325                                 LiquidType   LiquidType
21326                                 FlowingAlt   string
21327                                 SrcAlt       string
21328                                 Viscosity    uint8 // 0-7
21329                                 LiqRenewable bool
21330                                 FlowRange    uint8
21331                                 DrownDmg     uint8
21332                                 Floodable    bool
21333
21334                                 DrawBox, ColBox, SelBox NodeBox
21335
21336                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21337
21338                                 LegacyFaceDir bool
21339                                 LegacyMounted bool
21340
21341                                 DigPredict string
21342
21343                                 MaxLvl uint8
21344
21345                                 AlphaUse
21346                         }))(obj)).DrownDmg
21347                         *p = read8(r)
21348                 }
21349                 {
21350                         p := &(*(*(struct {
21351                                 Param0 Content
21352
21353                                 Name   string
21354                                 Groups []Group
21355
21356                                 P1Type   Param1Type
21357                                 P2Type   Param2Type
21358                                 DrawType DrawType
21359
21360                                 Mesh  string
21361                                 Scale float32
21362                                 //mt:const uint8(6)
21363                                 Tiles        [6]TileDef
21364                                 OverlayTiles [6]TileDef
21365                                 //mt:const uint8(6)
21366                                 SpecialTiles [6]TileDef
21367
21368                                 Color   color.NRGBA
21369                                 Palette Texture
21370
21371                                 Waving       WaveType
21372                                 ConnectSides uint8
21373                                 ConnectTo    []Content
21374                                 InsideTint   color.NRGBA
21375                                 Level        uint8 // Must be < 128.
21376
21377                                 Translucent bool // Sunlight is scattered and becomes normal light.
21378                                 Transparent bool // Sunlight isn't scattered.
21379                                 LightSrc    uint8
21380
21381                                 GndContent   bool
21382                                 Collides     bool
21383                                 Pointable    bool
21384                                 Diggable     bool
21385                                 Climbable    bool
21386                                 Replaceable  bool
21387                                 OnRightClick bool
21388
21389                                 DmgPerSec int32
21390
21391                                 LiquidType   LiquidType
21392                                 FlowingAlt   string
21393                                 SrcAlt       string
21394                                 Viscosity    uint8 // 0-7
21395                                 LiqRenewable bool
21396                                 FlowRange    uint8
21397                                 DrownDmg     uint8
21398                                 Floodable    bool
21399
21400                                 DrawBox, ColBox, SelBox NodeBox
21401
21402                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21403
21404                                 LegacyFaceDir bool
21405                                 LegacyMounted bool
21406
21407                                 DigPredict string
21408
21409                                 MaxLvl uint8
21410
21411                                 AlphaUse
21412                         }))(obj)).Floodable
21413                         switch n := read8(r); n {
21414                         case 0:
21415                                 *p = false
21416                         case 1:
21417                                 *p = true
21418                         default:
21419                                 chk(fmt.Errorf("invalid bool: %d", n))
21420                         }
21421                 }
21422                 if err := pcall(func() {
21423                         ((*(*(struct {
21424                                 Param0 Content
21425
21426                                 Name   string
21427                                 Groups []Group
21428
21429                                 P1Type   Param1Type
21430                                 P2Type   Param2Type
21431                                 DrawType DrawType
21432
21433                                 Mesh  string
21434                                 Scale float32
21435                                 //mt:const uint8(6)
21436                                 Tiles        [6]TileDef
21437                                 OverlayTiles [6]TileDef
21438                                 //mt:const uint8(6)
21439                                 SpecialTiles [6]TileDef
21440
21441                                 Color   color.NRGBA
21442                                 Palette Texture
21443
21444                                 Waving       WaveType
21445                                 ConnectSides uint8
21446                                 ConnectTo    []Content
21447                                 InsideTint   color.NRGBA
21448                                 Level        uint8 // Must be < 128.
21449
21450                                 Translucent bool // Sunlight is scattered and becomes normal light.
21451                                 Transparent bool // Sunlight isn't scattered.
21452                                 LightSrc    uint8
21453
21454                                 GndContent   bool
21455                                 Collides     bool
21456                                 Pointable    bool
21457                                 Diggable     bool
21458                                 Climbable    bool
21459                                 Replaceable  bool
21460                                 OnRightClick bool
21461
21462                                 DmgPerSec int32
21463
21464                                 LiquidType   LiquidType
21465                                 FlowingAlt   string
21466                                 SrcAlt       string
21467                                 Viscosity    uint8 // 0-7
21468                                 LiqRenewable bool
21469                                 FlowRange    uint8
21470                                 DrownDmg     uint8
21471                                 Floodable    bool
21472
21473                                 DrawBox, ColBox, SelBox NodeBox
21474
21475                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21476
21477                                 LegacyFaceDir bool
21478                                 LegacyMounted bool
21479
21480                                 DigPredict string
21481
21482                                 MaxLvl uint8
21483
21484                                 AlphaUse
21485                         }))(obj)).DrawBox).deserialize(r)
21486                 }); err != nil {
21487                         if err == io.EOF {
21488                                 chk(io.EOF)
21489                         }
21490                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
21491                 }
21492                 if err := pcall(func() {
21493                         ((*(*(struct {
21494                                 Param0 Content
21495
21496                                 Name   string
21497                                 Groups []Group
21498
21499                                 P1Type   Param1Type
21500                                 P2Type   Param2Type
21501                                 DrawType DrawType
21502
21503                                 Mesh  string
21504                                 Scale float32
21505                                 //mt:const uint8(6)
21506                                 Tiles        [6]TileDef
21507                                 OverlayTiles [6]TileDef
21508                                 //mt:const uint8(6)
21509                                 SpecialTiles [6]TileDef
21510
21511                                 Color   color.NRGBA
21512                                 Palette Texture
21513
21514                                 Waving       WaveType
21515                                 ConnectSides uint8
21516                                 ConnectTo    []Content
21517                                 InsideTint   color.NRGBA
21518                                 Level        uint8 // Must be < 128.
21519
21520                                 Translucent bool // Sunlight is scattered and becomes normal light.
21521                                 Transparent bool // Sunlight isn't scattered.
21522                                 LightSrc    uint8
21523
21524                                 GndContent   bool
21525                                 Collides     bool
21526                                 Pointable    bool
21527                                 Diggable     bool
21528                                 Climbable    bool
21529                                 Replaceable  bool
21530                                 OnRightClick bool
21531
21532                                 DmgPerSec int32
21533
21534                                 LiquidType   LiquidType
21535                                 FlowingAlt   string
21536                                 SrcAlt       string
21537                                 Viscosity    uint8 // 0-7
21538                                 LiqRenewable bool
21539                                 FlowRange    uint8
21540                                 DrownDmg     uint8
21541                                 Floodable    bool
21542
21543                                 DrawBox, ColBox, SelBox NodeBox
21544
21545                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21546
21547                                 LegacyFaceDir bool
21548                                 LegacyMounted bool
21549
21550                                 DigPredict string
21551
21552                                 MaxLvl uint8
21553
21554                                 AlphaUse
21555                         }))(obj)).ColBox).deserialize(r)
21556                 }); err != nil {
21557                         if err == io.EOF {
21558                                 chk(io.EOF)
21559                         }
21560                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
21561                 }
21562                 if err := pcall(func() {
21563                         ((*(*(struct {
21564                                 Param0 Content
21565
21566                                 Name   string
21567                                 Groups []Group
21568
21569                                 P1Type   Param1Type
21570                                 P2Type   Param2Type
21571                                 DrawType DrawType
21572
21573                                 Mesh  string
21574                                 Scale float32
21575                                 //mt:const uint8(6)
21576                                 Tiles        [6]TileDef
21577                                 OverlayTiles [6]TileDef
21578                                 //mt:const uint8(6)
21579                                 SpecialTiles [6]TileDef
21580
21581                                 Color   color.NRGBA
21582                                 Palette Texture
21583
21584                                 Waving       WaveType
21585                                 ConnectSides uint8
21586                                 ConnectTo    []Content
21587                                 InsideTint   color.NRGBA
21588                                 Level        uint8 // Must be < 128.
21589
21590                                 Translucent bool // Sunlight is scattered and becomes normal light.
21591                                 Transparent bool // Sunlight isn't scattered.
21592                                 LightSrc    uint8
21593
21594                                 GndContent   bool
21595                                 Collides     bool
21596                                 Pointable    bool
21597                                 Diggable     bool
21598                                 Climbable    bool
21599                                 Replaceable  bool
21600                                 OnRightClick bool
21601
21602                                 DmgPerSec int32
21603
21604                                 LiquidType   LiquidType
21605                                 FlowingAlt   string
21606                                 SrcAlt       string
21607                                 Viscosity    uint8 // 0-7
21608                                 LiqRenewable bool
21609                                 FlowRange    uint8
21610                                 DrownDmg     uint8
21611                                 Floodable    bool
21612
21613                                 DrawBox, ColBox, SelBox NodeBox
21614
21615                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21616
21617                                 LegacyFaceDir bool
21618                                 LegacyMounted bool
21619
21620                                 DigPredict string
21621
21622                                 MaxLvl uint8
21623
21624                                 AlphaUse
21625                         }))(obj)).SelBox).deserialize(r)
21626                 }); err != nil {
21627                         if err == io.EOF {
21628                                 chk(io.EOF)
21629                         }
21630                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
21631                 }
21632                 if err := pcall(func() {
21633                         ((*(*(struct {
21634                                 Param0 Content
21635
21636                                 Name   string
21637                                 Groups []Group
21638
21639                                 P1Type   Param1Type
21640                                 P2Type   Param2Type
21641                                 DrawType DrawType
21642
21643                                 Mesh  string
21644                                 Scale float32
21645                                 //mt:const uint8(6)
21646                                 Tiles        [6]TileDef
21647                                 OverlayTiles [6]TileDef
21648                                 //mt:const uint8(6)
21649                                 SpecialTiles [6]TileDef
21650
21651                                 Color   color.NRGBA
21652                                 Palette Texture
21653
21654                                 Waving       WaveType
21655                                 ConnectSides uint8
21656                                 ConnectTo    []Content
21657                                 InsideTint   color.NRGBA
21658                                 Level        uint8 // Must be < 128.
21659
21660                                 Translucent bool // Sunlight is scattered and becomes normal light.
21661                                 Transparent bool // Sunlight isn't scattered.
21662                                 LightSrc    uint8
21663
21664                                 GndContent   bool
21665                                 Collides     bool
21666                                 Pointable    bool
21667                                 Diggable     bool
21668                                 Climbable    bool
21669                                 Replaceable  bool
21670                                 OnRightClick bool
21671
21672                                 DmgPerSec int32
21673
21674                                 LiquidType   LiquidType
21675                                 FlowingAlt   string
21676                                 SrcAlt       string
21677                                 Viscosity    uint8 // 0-7
21678                                 LiqRenewable bool
21679                                 FlowRange    uint8
21680                                 DrownDmg     uint8
21681                                 Floodable    bool
21682
21683                                 DrawBox, ColBox, SelBox NodeBox
21684
21685                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21686
21687                                 LegacyFaceDir bool
21688                                 LegacyMounted bool
21689
21690                                 DigPredict string
21691
21692                                 MaxLvl uint8
21693
21694                                 AlphaUse
21695                         }))(obj)).FootstepSnd).deserialize(r)
21696                 }); err != nil {
21697                         if err == io.EOF {
21698                                 chk(io.EOF)
21699                         }
21700                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
21701                 }
21702                 if err := pcall(func() {
21703                         ((*(*(struct {
21704                                 Param0 Content
21705
21706                                 Name   string
21707                                 Groups []Group
21708
21709                                 P1Type   Param1Type
21710                                 P2Type   Param2Type
21711                                 DrawType DrawType
21712
21713                                 Mesh  string
21714                                 Scale float32
21715                                 //mt:const uint8(6)
21716                                 Tiles        [6]TileDef
21717                                 OverlayTiles [6]TileDef
21718                                 //mt:const uint8(6)
21719                                 SpecialTiles [6]TileDef
21720
21721                                 Color   color.NRGBA
21722                                 Palette Texture
21723
21724                                 Waving       WaveType
21725                                 ConnectSides uint8
21726                                 ConnectTo    []Content
21727                                 InsideTint   color.NRGBA
21728                                 Level        uint8 // Must be < 128.
21729
21730                                 Translucent bool // Sunlight is scattered and becomes normal light.
21731                                 Transparent bool // Sunlight isn't scattered.
21732                                 LightSrc    uint8
21733
21734                                 GndContent   bool
21735                                 Collides     bool
21736                                 Pointable    bool
21737                                 Diggable     bool
21738                                 Climbable    bool
21739                                 Replaceable  bool
21740                                 OnRightClick bool
21741
21742                                 DmgPerSec int32
21743
21744                                 LiquidType   LiquidType
21745                                 FlowingAlt   string
21746                                 SrcAlt       string
21747                                 Viscosity    uint8 // 0-7
21748                                 LiqRenewable bool
21749                                 FlowRange    uint8
21750                                 DrownDmg     uint8
21751                                 Floodable    bool
21752
21753                                 DrawBox, ColBox, SelBox NodeBox
21754
21755                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21756
21757                                 LegacyFaceDir bool
21758                                 LegacyMounted bool
21759
21760                                 DigPredict string
21761
21762                                 MaxLvl uint8
21763
21764                                 AlphaUse
21765                         }))(obj)).DiggingSnd).deserialize(r)
21766                 }); err != nil {
21767                         if err == io.EOF {
21768                                 chk(io.EOF)
21769                         }
21770                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
21771                 }
21772                 if err := pcall(func() {
21773                         ((*(*(struct {
21774                                 Param0 Content
21775
21776                                 Name   string
21777                                 Groups []Group
21778
21779                                 P1Type   Param1Type
21780                                 P2Type   Param2Type
21781                                 DrawType DrawType
21782
21783                                 Mesh  string
21784                                 Scale float32
21785                                 //mt:const uint8(6)
21786                                 Tiles        [6]TileDef
21787                                 OverlayTiles [6]TileDef
21788                                 //mt:const uint8(6)
21789                                 SpecialTiles [6]TileDef
21790
21791                                 Color   color.NRGBA
21792                                 Palette Texture
21793
21794                                 Waving       WaveType
21795                                 ConnectSides uint8
21796                                 ConnectTo    []Content
21797                                 InsideTint   color.NRGBA
21798                                 Level        uint8 // Must be < 128.
21799
21800                                 Translucent bool // Sunlight is scattered and becomes normal light.
21801                                 Transparent bool // Sunlight isn't scattered.
21802                                 LightSrc    uint8
21803
21804                                 GndContent   bool
21805                                 Collides     bool
21806                                 Pointable    bool
21807                                 Diggable     bool
21808                                 Climbable    bool
21809                                 Replaceable  bool
21810                                 OnRightClick bool
21811
21812                                 DmgPerSec int32
21813
21814                                 LiquidType   LiquidType
21815                                 FlowingAlt   string
21816                                 SrcAlt       string
21817                                 Viscosity    uint8 // 0-7
21818                                 LiqRenewable bool
21819                                 FlowRange    uint8
21820                                 DrownDmg     uint8
21821                                 Floodable    bool
21822
21823                                 DrawBox, ColBox, SelBox NodeBox
21824
21825                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21826
21827                                 LegacyFaceDir bool
21828                                 LegacyMounted bool
21829
21830                                 DigPredict string
21831
21832                                 MaxLvl uint8
21833
21834                                 AlphaUse
21835                         }))(obj)).DugSnd).deserialize(r)
21836                 }); err != nil {
21837                         if err == io.EOF {
21838                                 chk(io.EOF)
21839                         }
21840                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
21841                 }
21842                 {
21843                         p := &(*(*(struct {
21844                                 Param0 Content
21845
21846                                 Name   string
21847                                 Groups []Group
21848
21849                                 P1Type   Param1Type
21850                                 P2Type   Param2Type
21851                                 DrawType DrawType
21852
21853                                 Mesh  string
21854                                 Scale float32
21855                                 //mt:const uint8(6)
21856                                 Tiles        [6]TileDef
21857                                 OverlayTiles [6]TileDef
21858                                 //mt:const uint8(6)
21859                                 SpecialTiles [6]TileDef
21860
21861                                 Color   color.NRGBA
21862                                 Palette Texture
21863
21864                                 Waving       WaveType
21865                                 ConnectSides uint8
21866                                 ConnectTo    []Content
21867                                 InsideTint   color.NRGBA
21868                                 Level        uint8 // Must be < 128.
21869
21870                                 Translucent bool // Sunlight is scattered and becomes normal light.
21871                                 Transparent bool // Sunlight isn't scattered.
21872                                 LightSrc    uint8
21873
21874                                 GndContent   bool
21875                                 Collides     bool
21876                                 Pointable    bool
21877                                 Diggable     bool
21878                                 Climbable    bool
21879                                 Replaceable  bool
21880                                 OnRightClick bool
21881
21882                                 DmgPerSec int32
21883
21884                                 LiquidType   LiquidType
21885                                 FlowingAlt   string
21886                                 SrcAlt       string
21887                                 Viscosity    uint8 // 0-7
21888                                 LiqRenewable bool
21889                                 FlowRange    uint8
21890                                 DrownDmg     uint8
21891                                 Floodable    bool
21892
21893                                 DrawBox, ColBox, SelBox NodeBox
21894
21895                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21896
21897                                 LegacyFaceDir bool
21898                                 LegacyMounted bool
21899
21900                                 DigPredict string
21901
21902                                 MaxLvl uint8
21903
21904                                 AlphaUse
21905                         }))(obj)).LegacyFaceDir
21906                         switch n := read8(r); n {
21907                         case 0:
21908                                 *p = false
21909                         case 1:
21910                                 *p = true
21911                         default:
21912                                 chk(fmt.Errorf("invalid bool: %d", n))
21913                         }
21914                 }
21915                 {
21916                         p := &(*(*(struct {
21917                                 Param0 Content
21918
21919                                 Name   string
21920                                 Groups []Group
21921
21922                                 P1Type   Param1Type
21923                                 P2Type   Param2Type
21924                                 DrawType DrawType
21925
21926                                 Mesh  string
21927                                 Scale float32
21928                                 //mt:const uint8(6)
21929                                 Tiles        [6]TileDef
21930                                 OverlayTiles [6]TileDef
21931                                 //mt:const uint8(6)
21932                                 SpecialTiles [6]TileDef
21933
21934                                 Color   color.NRGBA
21935                                 Palette Texture
21936
21937                                 Waving       WaveType
21938                                 ConnectSides uint8
21939                                 ConnectTo    []Content
21940                                 InsideTint   color.NRGBA
21941                                 Level        uint8 // Must be < 128.
21942
21943                                 Translucent bool // Sunlight is scattered and becomes normal light.
21944                                 Transparent bool // Sunlight isn't scattered.
21945                                 LightSrc    uint8
21946
21947                                 GndContent   bool
21948                                 Collides     bool
21949                                 Pointable    bool
21950                                 Diggable     bool
21951                                 Climbable    bool
21952                                 Replaceable  bool
21953                                 OnRightClick bool
21954
21955                                 DmgPerSec int32
21956
21957                                 LiquidType   LiquidType
21958                                 FlowingAlt   string
21959                                 SrcAlt       string
21960                                 Viscosity    uint8 // 0-7
21961                                 LiqRenewable bool
21962                                 FlowRange    uint8
21963                                 DrownDmg     uint8
21964                                 Floodable    bool
21965
21966                                 DrawBox, ColBox, SelBox NodeBox
21967
21968                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21969
21970                                 LegacyFaceDir bool
21971                                 LegacyMounted bool
21972
21973                                 DigPredict string
21974
21975                                 MaxLvl uint8
21976
21977                                 AlphaUse
21978                         }))(obj)).LegacyMounted
21979                         switch n := read8(r); n {
21980                         case 0:
21981                                 *p = false
21982                         case 1:
21983                                 *p = true
21984                         default:
21985                                 chk(fmt.Errorf("invalid bool: %d", n))
21986                         }
21987                 }
21988                 var local267 []uint8
21989                 var local268 uint16
21990                 {
21991                         p := &local268
21992                         *p = read16(r)
21993                 }
21994                 (local267) = make([]uint8, local268)
21995                 {
21996                         _, err := io.ReadFull(r, (local267)[:])
21997                         chk(err)
21998                 }
21999                 ((*(*(struct {
22000                         Param0 Content
22001
22002                         Name   string
22003                         Groups []Group
22004
22005                         P1Type   Param1Type
22006                         P2Type   Param2Type
22007                         DrawType DrawType
22008
22009                         Mesh  string
22010                         Scale float32
22011                         //mt:const uint8(6)
22012                         Tiles        [6]TileDef
22013                         OverlayTiles [6]TileDef
22014                         //mt:const uint8(6)
22015                         SpecialTiles [6]TileDef
22016
22017                         Color   color.NRGBA
22018                         Palette Texture
22019
22020                         Waving       WaveType
22021                         ConnectSides uint8
22022                         ConnectTo    []Content
22023                         InsideTint   color.NRGBA
22024                         Level        uint8 // Must be < 128.
22025
22026                         Translucent bool // Sunlight is scattered and becomes normal light.
22027                         Transparent bool // Sunlight isn't scattered.
22028                         LightSrc    uint8
22029
22030                         GndContent   bool
22031                         Collides     bool
22032                         Pointable    bool
22033                         Diggable     bool
22034                         Climbable    bool
22035                         Replaceable  bool
22036                         OnRightClick bool
22037
22038                         DmgPerSec int32
22039
22040                         LiquidType   LiquidType
22041                         FlowingAlt   string
22042                         SrcAlt       string
22043                         Viscosity    uint8 // 0-7
22044                         LiqRenewable bool
22045                         FlowRange    uint8
22046                         DrownDmg     uint8
22047                         Floodable    bool
22048
22049                         DrawBox, ColBox, SelBox NodeBox
22050
22051                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22052
22053                         LegacyFaceDir bool
22054                         LegacyMounted bool
22055
22056                         DigPredict string
22057
22058                         MaxLvl uint8
22059
22060                         AlphaUse
22061                 }))(obj)).DigPredict) = string(local267)
22062                 {
22063                         p := &(*(*(struct {
22064                                 Param0 Content
22065
22066                                 Name   string
22067                                 Groups []Group
22068
22069                                 P1Type   Param1Type
22070                                 P2Type   Param2Type
22071                                 DrawType DrawType
22072
22073                                 Mesh  string
22074                                 Scale float32
22075                                 //mt:const uint8(6)
22076                                 Tiles        [6]TileDef
22077                                 OverlayTiles [6]TileDef
22078                                 //mt:const uint8(6)
22079                                 SpecialTiles [6]TileDef
22080
22081                                 Color   color.NRGBA
22082                                 Palette Texture
22083
22084                                 Waving       WaveType
22085                                 ConnectSides uint8
22086                                 ConnectTo    []Content
22087                                 InsideTint   color.NRGBA
22088                                 Level        uint8 // Must be < 128.
22089
22090                                 Translucent bool // Sunlight is scattered and becomes normal light.
22091                                 Transparent bool // Sunlight isn't scattered.
22092                                 LightSrc    uint8
22093
22094                                 GndContent   bool
22095                                 Collides     bool
22096                                 Pointable    bool
22097                                 Diggable     bool
22098                                 Climbable    bool
22099                                 Replaceable  bool
22100                                 OnRightClick bool
22101
22102                                 DmgPerSec int32
22103
22104                                 LiquidType   LiquidType
22105                                 FlowingAlt   string
22106                                 SrcAlt       string
22107                                 Viscosity    uint8 // 0-7
22108                                 LiqRenewable bool
22109                                 FlowRange    uint8
22110                                 DrownDmg     uint8
22111                                 Floodable    bool
22112
22113                                 DrawBox, ColBox, SelBox NodeBox
22114
22115                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22116
22117                                 LegacyFaceDir bool
22118                                 LegacyMounted bool
22119
22120                                 DigPredict string
22121
22122                                 MaxLvl uint8
22123
22124                                 AlphaUse
22125                         }))(obj)).MaxLvl
22126                         *p = read8(r)
22127                 }
22128                 if err := pcall(func() {
22129                         ((*(*(struct {
22130                                 Param0 Content
22131
22132                                 Name   string
22133                                 Groups []Group
22134
22135                                 P1Type   Param1Type
22136                                 P2Type   Param2Type
22137                                 DrawType DrawType
22138
22139                                 Mesh  string
22140                                 Scale float32
22141                                 //mt:const uint8(6)
22142                                 Tiles        [6]TileDef
22143                                 OverlayTiles [6]TileDef
22144                                 //mt:const uint8(6)
22145                                 SpecialTiles [6]TileDef
22146
22147                                 Color   color.NRGBA
22148                                 Palette Texture
22149
22150                                 Waving       WaveType
22151                                 ConnectSides uint8
22152                                 ConnectTo    []Content
22153                                 InsideTint   color.NRGBA
22154                                 Level        uint8 // Must be < 128.
22155
22156                                 Translucent bool // Sunlight is scattered and becomes normal light.
22157                                 Transparent bool // Sunlight isn't scattered.
22158                                 LightSrc    uint8
22159
22160                                 GndContent   bool
22161                                 Collides     bool
22162                                 Pointable    bool
22163                                 Diggable     bool
22164                                 Climbable    bool
22165                                 Replaceable  bool
22166                                 OnRightClick bool
22167
22168                                 DmgPerSec int32
22169
22170                                 LiquidType   LiquidType
22171                                 FlowingAlt   string
22172                                 SrcAlt       string
22173                                 Viscosity    uint8 // 0-7
22174                                 LiqRenewable bool
22175                                 FlowRange    uint8
22176                                 DrownDmg     uint8
22177                                 Floodable    bool
22178
22179                                 DrawBox, ColBox, SelBox NodeBox
22180
22181                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22182
22183                                 LegacyFaceDir bool
22184                                 LegacyMounted bool
22185
22186                                 DigPredict string
22187
22188                                 MaxLvl uint8
22189
22190                                 AlphaUse
22191                         }))(obj)).AlphaUse).deserialize(r)
22192                 }); err != nil {
22193                         if err == io.EOF {
22194                                 chk(io.EOF)
22195                         }
22196                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlphaUse", err))
22197                 }
22198                 if r.N > 0 {
22199                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
22200                 }
22201         }
22202 }
22203
22204 func (obj *PointedNode) serialize(w io.Writer) {
22205         for local269 := range (*(*(struct {
22206                 Under, Above [3]int16
22207         }))(obj)).Under {
22208                 {
22209                         x := ((*(*(struct {
22210                                 Under, Above [3]int16
22211                         }))(obj)).Under)[local269]
22212                         write16(w, uint16(x))
22213                 }
22214         }
22215         for local270 := range (*(*(struct {
22216                 Under, Above [3]int16
22217         }))(obj)).Above {
22218                 {
22219                         x := ((*(*(struct {
22220                                 Under, Above [3]int16
22221                         }))(obj)).Above)[local270]
22222                         write16(w, uint16(x))
22223                 }
22224         }
22225 }
22226
22227 func (obj *PointedNode) deserialize(r io.Reader) {
22228         for local271 := range (*(*(struct {
22229                 Under, Above [3]int16
22230         }))(obj)).Under {
22231                 {
22232                         p := &((*(*(struct {
22233                                 Under, Above [3]int16
22234                         }))(obj)).Under)[local271]
22235                         *p = int16(read16(r))
22236                 }
22237         }
22238         for local272 := range (*(*(struct {
22239                 Under, Above [3]int16
22240         }))(obj)).Above {
22241                 {
22242                         p := &((*(*(struct {
22243                                 Under, Above [3]int16
22244                         }))(obj)).Above)[local272]
22245                         *p = int16(read16(r))
22246                 }
22247         }
22248 }
22249
22250 func (obj *PointedAO) serialize(w io.Writer) {
22251         if err := pcall(func() {
22252                 ((*(*(struct {
22253                         ID AOID
22254                 }))(obj)).ID).serialize(w)
22255         }); err != nil {
22256                 if err == io.EOF {
22257                         chk(io.EOF)
22258                 }
22259                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
22260         }
22261 }
22262
22263 func (obj *PointedAO) deserialize(r io.Reader) {
22264         if err := pcall(func() {
22265                 ((*(*(struct {
22266                         ID AOID
22267                 }))(obj)).ID).deserialize(r)
22268         }); err != nil {
22269                 if err == io.EOF {
22270                         chk(io.EOF)
22271                 }
22272                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
22273         }
22274 }
22275
22276 func (obj *CompressionModes) serialize(w io.Writer) {
22277         {
22278                 x := *(*(uint16))(obj)
22279                 write16(w, uint16(x))
22280         }
22281 }
22282
22283 func (obj *CompressionModes) deserialize(r io.Reader) {
22284         {
22285                 p := &*(*(uint16))(obj)
22286                 *p = read16(r)
22287         }
22288 }
22289
22290 func (obj *PlayerPos) serialize(w io.Writer) {
22291         for local273 := range (*(*(struct {
22292                 Pos100, Vel100   [3]int32
22293                 Pitch100, Yaw100 int32
22294                 Keys             Keys
22295                 FOV80            uint8
22296                 WantedRange      uint8 // in MapBlks.
22297         }))(obj)).Pos100 {
22298                 {
22299                         x := ((*(*(struct {
22300                                 Pos100, Vel100   [3]int32
22301                                 Pitch100, Yaw100 int32
22302                                 Keys             Keys
22303                                 FOV80            uint8
22304                                 WantedRange      uint8 // in MapBlks.
22305                         }))(obj)).Pos100)[local273]
22306                         write32(w, uint32(x))
22307                 }
22308         }
22309         for local274 := range (*(*(struct {
22310                 Pos100, Vel100   [3]int32
22311                 Pitch100, Yaw100 int32
22312                 Keys             Keys
22313                 FOV80            uint8
22314                 WantedRange      uint8 // in MapBlks.
22315         }))(obj)).Vel100 {
22316                 {
22317                         x := ((*(*(struct {
22318                                 Pos100, Vel100   [3]int32
22319                                 Pitch100, Yaw100 int32
22320                                 Keys             Keys
22321                                 FOV80            uint8
22322                                 WantedRange      uint8 // in MapBlks.
22323                         }))(obj)).Vel100)[local274]
22324                         write32(w, uint32(x))
22325                 }
22326         }
22327         {
22328                 x := (*(*(struct {
22329                         Pos100, Vel100   [3]int32
22330                         Pitch100, Yaw100 int32
22331                         Keys             Keys
22332                         FOV80            uint8
22333                         WantedRange      uint8 // in MapBlks.
22334                 }))(obj)).Pitch100
22335                 write32(w, uint32(x))
22336         }
22337         {
22338                 x := (*(*(struct {
22339                         Pos100, Vel100   [3]int32
22340                         Pitch100, Yaw100 int32
22341                         Keys             Keys
22342                         FOV80            uint8
22343                         WantedRange      uint8 // in MapBlks.
22344                 }))(obj)).Yaw100
22345                 write32(w, uint32(x))
22346         }
22347         if err := pcall(func() {
22348                 ((*(*(struct {
22349                         Pos100, Vel100   [3]int32
22350                         Pitch100, Yaw100 int32
22351                         Keys             Keys
22352                         FOV80            uint8
22353                         WantedRange      uint8 // in MapBlks.
22354                 }))(obj)).Keys).serialize(w)
22355         }); err != nil {
22356                 if err == io.EOF {
22357                         chk(io.EOF)
22358                 }
22359                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Keys", err))
22360         }
22361         {
22362                 x := (*(*(struct {
22363                         Pos100, Vel100   [3]int32
22364                         Pitch100, Yaw100 int32
22365                         Keys             Keys
22366                         FOV80            uint8
22367                         WantedRange      uint8 // in MapBlks.
22368                 }))(obj)).FOV80
22369                 write8(w, uint8(x))
22370         }
22371         {
22372                 x := (*(*(struct {
22373                         Pos100, Vel100   [3]int32
22374                         Pitch100, Yaw100 int32
22375                         Keys             Keys
22376                         FOV80            uint8
22377                         WantedRange      uint8 // in MapBlks.
22378                 }))(obj)).WantedRange
22379                 write8(w, uint8(x))
22380         }
22381 }
22382
22383 func (obj *PlayerPos) deserialize(r io.Reader) {
22384         for local275 := range (*(*(struct {
22385                 Pos100, Vel100   [3]int32
22386                 Pitch100, Yaw100 int32
22387                 Keys             Keys
22388                 FOV80            uint8
22389                 WantedRange      uint8 // in MapBlks.
22390         }))(obj)).Pos100 {
22391                 {
22392                         p := &((*(*(struct {
22393                                 Pos100, Vel100   [3]int32
22394                                 Pitch100, Yaw100 int32
22395                                 Keys             Keys
22396                                 FOV80            uint8
22397                                 WantedRange      uint8 // in MapBlks.
22398                         }))(obj)).Pos100)[local275]
22399                         *p = int32(read32(r))
22400                 }
22401         }
22402         for local276 := range (*(*(struct {
22403                 Pos100, Vel100   [3]int32
22404                 Pitch100, Yaw100 int32
22405                 Keys             Keys
22406                 FOV80            uint8
22407                 WantedRange      uint8 // in MapBlks.
22408         }))(obj)).Vel100 {
22409                 {
22410                         p := &((*(*(struct {
22411                                 Pos100, Vel100   [3]int32
22412                                 Pitch100, Yaw100 int32
22413                                 Keys             Keys
22414                                 FOV80            uint8
22415                                 WantedRange      uint8 // in MapBlks.
22416                         }))(obj)).Vel100)[local276]
22417                         *p = int32(read32(r))
22418                 }
22419         }
22420         {
22421                 p := &(*(*(struct {
22422                         Pos100, Vel100   [3]int32
22423                         Pitch100, Yaw100 int32
22424                         Keys             Keys
22425                         FOV80            uint8
22426                         WantedRange      uint8 // in MapBlks.
22427                 }))(obj)).Pitch100
22428                 *p = int32(read32(r))
22429         }
22430         {
22431                 p := &(*(*(struct {
22432                         Pos100, Vel100   [3]int32
22433                         Pitch100, Yaw100 int32
22434                         Keys             Keys
22435                         FOV80            uint8
22436                         WantedRange      uint8 // in MapBlks.
22437                 }))(obj)).Yaw100
22438                 *p = int32(read32(r))
22439         }
22440         if err := pcall(func() {
22441                 ((*(*(struct {
22442                         Pos100, Vel100   [3]int32
22443                         Pitch100, Yaw100 int32
22444                         Keys             Keys
22445                         FOV80            uint8
22446                         WantedRange      uint8 // in MapBlks.
22447                 }))(obj)).Keys).deserialize(r)
22448         }); err != nil {
22449                 if err == io.EOF {
22450                         chk(io.EOF)
22451                 }
22452                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Keys", err))
22453         }
22454         {
22455                 p := &(*(*(struct {
22456                         Pos100, Vel100   [3]int32
22457                         Pitch100, Yaw100 int32
22458                         Keys             Keys
22459                         FOV80            uint8
22460                         WantedRange      uint8 // in MapBlks.
22461                 }))(obj)).FOV80
22462                 *p = read8(r)
22463         }
22464         {
22465                 p := &(*(*(struct {
22466                         Pos100, Vel100   [3]int32
22467                         Pitch100, Yaw100 int32
22468                         Keys             Keys
22469                         FOV80            uint8
22470                         WantedRange      uint8 // in MapBlks.
22471                 }))(obj)).WantedRange
22472                 *p = read8(r)
22473         }
22474 }
22475
22476 func (obj *Interaction) serialize(w io.Writer) {
22477         {
22478                 x := *(*(uint8))(obj)
22479                 write8(w, uint8(x))
22480         }
22481 }
22482
22483 func (obj *Interaction) deserialize(r io.Reader) {
22484         {
22485                 p := &*(*(uint8))(obj)
22486                 *p = read8(r)
22487         }
22488 }
22489
22490 func (obj *SoundID) serialize(w io.Writer) {
22491         {
22492                 x := *(*(int32))(obj)
22493                 write32(w, uint32(x))
22494         }
22495 }
22496
22497 func (obj *SoundID) deserialize(r io.Reader) {
22498         {
22499                 p := &*(*(int32))(obj)
22500                 *p = int32(read32(r))
22501         }
22502 }
22503
22504 func (obj *Field) serialize(w io.Writer) {
22505         if len(([]byte((*(*(struct {
22506                 Name string
22507
22508                 //mt:len32
22509                 Value string
22510         }))(obj)).Name))) > math.MaxUint16 {
22511                 chk(ErrTooLong)
22512         }
22513         {
22514                 x := uint16(len(([]byte((*(*(struct {
22515                         Name string
22516
22517                         //mt:len32
22518                         Value string
22519                 }))(obj)).Name))))
22520                 write16(w, uint16(x))
22521         }
22522         {
22523                 _, err := w.Write(([]byte((*(*(struct {
22524                         Name string
22525
22526                         //mt:len32
22527                         Value string
22528                 }))(obj)).Name))[:])
22529                 chk(err)
22530         }
22531         if len(([]byte((*(*(struct {
22532                 Name string
22533
22534                 //mt:len32
22535                 Value string
22536         }))(obj)).Value))) > math.MaxUint32 {
22537                 chk(ErrTooLong)
22538         }
22539         {
22540                 x := uint32(len(([]byte((*(*(struct {
22541                         Name string
22542
22543                         //mt:len32
22544                         Value string
22545                 }))(obj)).Value))))
22546                 write32(w, uint32(x))
22547         }
22548         {
22549                 _, err := w.Write(([]byte((*(*(struct {
22550                         Name string
22551
22552                         //mt:len32
22553                         Value string
22554                 }))(obj)).Value))[:])
22555                 chk(err)
22556         }
22557 }
22558
22559 func (obj *Field) deserialize(r io.Reader) {
22560         var local277 []uint8
22561         var local278 uint16
22562         {
22563                 p := &local278
22564                 *p = read16(r)
22565         }
22566         (local277) = make([]uint8, local278)
22567         {
22568                 _, err := io.ReadFull(r, (local277)[:])
22569                 chk(err)
22570         }
22571         ((*(*(struct {
22572                 Name string
22573
22574                 //mt:len32
22575                 Value string
22576         }))(obj)).Name) = string(local277)
22577         var local279 []uint8
22578         var local280 uint32
22579         {
22580                 p := &local280
22581                 *p = read32(r)
22582         }
22583         (local279) = make([]uint8, local280)
22584         {
22585                 _, err := io.ReadFull(r, (local279)[:])
22586                 chk(err)
22587         }
22588         ((*(*(struct {
22589                 Name string
22590
22591                 //mt:len32
22592                 Value string
22593         }))(obj)).Value) = string(local279)
22594 }
22595
22596 func (obj *AuthMethods) serialize(w io.Writer) {
22597         {
22598                 x := *(*(uint32))(obj)
22599                 write32(w, uint32(x))
22600         }
22601 }
22602
22603 func (obj *AuthMethods) deserialize(r io.Reader) {
22604         {
22605                 p := &*(*(uint32))(obj)
22606                 *p = read32(r)
22607         }
22608 }
22609
22610 func (obj *Pos) serialize(w io.Writer) {
22611         if err := pcall(func() {
22612                 (*(*(Vec))(obj)).serialize(w)
22613         }); err != nil {
22614                 if err == io.EOF {
22615                         chk(io.EOF)
22616                 }
22617                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
22618         }
22619 }
22620
22621 func (obj *Pos) deserialize(r io.Reader) {
22622         if err := pcall(func() {
22623                 (*(*(Vec))(obj)).deserialize(r)
22624         }); err != nil {
22625                 if err == io.EOF {
22626                         chk(io.EOF)
22627                 }
22628                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
22629         }
22630 }
22631
22632 func (obj *KickReason) serialize(w io.Writer) {
22633         {
22634                 x := *(*(uint8))(obj)
22635                 write8(w, uint8(x))
22636         }
22637 }
22638
22639 func (obj *KickReason) deserialize(r io.Reader) {
22640         {
22641                 p := &*(*(uint8))(obj)
22642                 *p = read8(r)
22643         }
22644 }
22645
22646 func (obj *MapBlk) serialize(w io.Writer) {
22647         if err := pcall(func() {
22648                 ((*(*(struct {
22649                         Flags   MapBlkFlags
22650                         LitFrom LitFromBlks
22651
22652                         //mt:zstd
22653                         Param0 [4096]Content
22654                         Param1 [4096]uint8
22655                         Param2 [4096]uint8
22656
22657                         NodeMetas map[uint16]*NodeMeta
22658                 }))(obj)).Flags).serialize(w)
22659         }); err != nil {
22660                 if err == io.EOF {
22661                         chk(io.EOF)
22662                 }
22663                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlkFlags", err))
22664         }
22665         if err := pcall(func() {
22666                 ((*(*(struct {
22667                         Flags   MapBlkFlags
22668                         LitFrom LitFromBlks
22669
22670                         //mt:zstd
22671                         Param0 [4096]Content
22672                         Param1 [4096]uint8
22673                         Param2 [4096]uint8
22674
22675                         NodeMetas map[uint16]*NodeMeta
22676                 }))(obj)).LitFrom).serialize(w)
22677         }); err != nil {
22678                 if err == io.EOF {
22679                         chk(io.EOF)
22680                 }
22681                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LitFromBlks", err))
22682         }
22683         {
22684                 local281 := uint8(2) // Size of param0 in bytes.
22685                 {
22686                         x := local281
22687                         write8(w, uint8(x))
22688                 }
22689         }
22690         {
22691                 local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22692                 {
22693                         x := local282
22694                         write8(w, uint8(x))
22695                 }
22696         }
22697         {
22698                 w, err := zstd.NewWriter(w)
22699                 chk(err)
22700                 for local283 := range (*(*(struct {
22701                         Flags   MapBlkFlags
22702                         LitFrom LitFromBlks
22703
22704                         //mt:zstd
22705                         Param0 [4096]Content
22706                         Param1 [4096]uint8
22707                         Param2 [4096]uint8
22708
22709                         NodeMetas map[uint16]*NodeMeta
22710                 }))(obj)).Param0 {
22711                         if err := pcall(func() {
22712                                 (((*(*(struct {
22713                                         Flags   MapBlkFlags
22714                                         LitFrom LitFromBlks
22715
22716                                         //mt:zstd
22717                                         Param0 [4096]Content
22718                                         Param1 [4096]uint8
22719                                         Param2 [4096]uint8
22720
22721                                         NodeMetas map[uint16]*NodeMeta
22722                                 }))(obj)).Param0)[local283]).serialize(w)
22723                         }); err != nil {
22724                                 if err == io.EOF {
22725                                         chk(io.EOF)
22726                                 }
22727                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
22728                         }
22729                 }
22730                 {
22731                         _, err := w.Write(((*(*(struct {
22732                                 Flags   MapBlkFlags
22733                                 LitFrom LitFromBlks
22734
22735                                 //mt:zstd
22736                                 Param0 [4096]Content
22737                                 Param1 [4096]uint8
22738                                 Param2 [4096]uint8
22739
22740                                 NodeMetas map[uint16]*NodeMeta
22741                         }))(obj)).Param1)[:])
22742                         chk(err)
22743                 }
22744                 {
22745                         _, err := w.Write(((*(*(struct {
22746                                 Flags   MapBlkFlags
22747                                 LitFrom LitFromBlks
22748
22749                                 //mt:zstd
22750                                 Param0 [4096]Content
22751                                 Param1 [4096]uint8
22752                                 Param2 [4096]uint8
22753
22754                                 NodeMetas map[uint16]*NodeMeta
22755                         }))(obj)).Param2)[:])
22756                         chk(err)
22757                 }
22758                 chk(w.Close())
22759         }
22760         {
22761                 x := (*(*(struct {
22762                         Flags   MapBlkFlags
22763                         LitFrom LitFromBlks
22764
22765                         //mt:zstd
22766                         Param0 [4096]Content
22767                         Param1 [4096]uint8
22768                         Param2 [4096]uint8
22769
22770                         NodeMetas map[uint16]*NodeMeta
22771                 }))(obj)).NodeMetas
22772                 {
22773                         w := zlib.NewWriter(w)
22774                         if x == nil {
22775                                 write8(w, 0)
22776                         } else {
22777                                 write8(w, 2)
22778                                 // len(map[uint16]...) always < math.MaxUint16
22779                                 write16(w, uint16(len(x)))
22780                                 keys := make([]uint16, 0, len(x))
22781                                 for key := range x {
22782                                         keys = append(keys, key)
22783                                 }
22784                                 sort.Slice(keys, func(i, j int) bool {
22785                                         i2pos := func(i int) [3]int16 {
22786                                                 return Blkpos2Pos([3]int16{}, keys[i])
22787                                         }
22788                                         p, q := i2pos(i), i2pos(j)
22789                                         for i := range p {
22790                                                 switch {
22791                                                 case p[i] < q[i]:
22792                                                         return true
22793                                                 case p[i] > q[i]:
22794                                                         return false
22795                                                 }
22796                                         }
22797                                         return false
22798                                 })
22799                                 for _, key := range keys {
22800                                         write16(w, key)
22801                                         chk(serialize(w, x[key]))
22802                                 }
22803                         }
22804                         chk(w.Close())
22805                 }
22806         }
22807         {
22808                 local284 := uint8(2) // version
22809                 {
22810                         x := local284
22811                         write8(w, uint8(x))
22812                 }
22813         }
22814 }
22815
22816 func (obj *MapBlk) deserialize(r io.Reader) {
22817         if err := pcall(func() {
22818                 ((*(*(struct {
22819                         Flags   MapBlkFlags
22820                         LitFrom LitFromBlks
22821
22822                         //mt:zstd
22823                         Param0 [4096]Content
22824                         Param1 [4096]uint8
22825                         Param2 [4096]uint8
22826
22827                         NodeMetas map[uint16]*NodeMeta
22828                 }))(obj)).Flags).deserialize(r)
22829         }); err != nil {
22830                 if err == io.EOF {
22831                         chk(io.EOF)
22832                 }
22833                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlkFlags", err))
22834         }
22835         if err := pcall(func() {
22836                 ((*(*(struct {
22837                         Flags   MapBlkFlags
22838                         LitFrom LitFromBlks
22839
22840                         //mt:zstd
22841                         Param0 [4096]Content
22842                         Param1 [4096]uint8
22843                         Param2 [4096]uint8
22844
22845                         NodeMetas map[uint16]*NodeMeta
22846                 }))(obj)).LitFrom).deserialize(r)
22847         }); err != nil {
22848                 if err == io.EOF {
22849                         chk(io.EOF)
22850                 }
22851                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LitFromBlks", err))
22852         }
22853         {
22854                 var local285 uint8
22855                 local286 := uint8(2) // Size of param0 in bytes.
22856                 {
22857                         p := &local285
22858                         *p = read8(r)
22859                 }
22860                 if local285 != local286 {
22861                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local285))
22862                 }
22863         }
22864         {
22865                 var local287 uint8
22866                 local288 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22867                 {
22868                         p := &local287
22869                         *p = read8(r)
22870                 }
22871                 if local287 != local288 {
22872                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local287))
22873                 }
22874         }
22875         {
22876                 r, err := zstd.NewReader(byteReader{r})
22877                 chk(err)
22878                 for local289 := range (*(*(struct {
22879                         Flags   MapBlkFlags
22880                         LitFrom LitFromBlks
22881
22882                         //mt:zstd
22883                         Param0 [4096]Content
22884                         Param1 [4096]uint8
22885                         Param2 [4096]uint8
22886
22887                         NodeMetas map[uint16]*NodeMeta
22888                 }))(obj)).Param0 {
22889                         if err := pcall(func() {
22890                                 (((*(*(struct {
22891                                         Flags   MapBlkFlags
22892                                         LitFrom LitFromBlks
22893
22894                                         //mt:zstd
22895                                         Param0 [4096]Content
22896                                         Param1 [4096]uint8
22897                                         Param2 [4096]uint8
22898
22899                                         NodeMetas map[uint16]*NodeMeta
22900                                 }))(obj)).Param0)[local289]).deserialize(r)
22901                         }); err != nil {
22902                                 if err == io.EOF {
22903                                         chk(io.EOF)
22904                                 }
22905                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
22906                         }
22907                 }
22908                 {
22909                         _, err := io.ReadFull(r, ((*(*(struct {
22910                                 Flags   MapBlkFlags
22911                                 LitFrom LitFromBlks
22912
22913                                 //mt:zstd
22914                                 Param0 [4096]Content
22915                                 Param1 [4096]uint8
22916                                 Param2 [4096]uint8
22917
22918                                 NodeMetas map[uint16]*NodeMeta
22919                         }))(obj)).Param1)[:])
22920                         chk(err)
22921                 }
22922                 {
22923                         _, err := io.ReadFull(r, ((*(*(struct {
22924                                 Flags   MapBlkFlags
22925                                 LitFrom LitFromBlks
22926
22927                                 //mt:zstd
22928                                 Param0 [4096]Content
22929                                 Param1 [4096]uint8
22930                                 Param2 [4096]uint8
22931
22932                                 NodeMetas map[uint16]*NodeMeta
22933                         }))(obj)).Param2)[:])
22934                         chk(err)
22935                 }
22936                 r.Close()
22937         }
22938         {
22939                 p := &(*(*(struct {
22940                         Flags   MapBlkFlags
22941                         LitFrom LitFromBlks
22942
22943                         //mt:zstd
22944                         Param0 [4096]Content
22945                         Param1 [4096]uint8
22946                         Param2 [4096]uint8
22947
22948                         NodeMetas map[uint16]*NodeMeta
22949                 }))(obj)).NodeMetas
22950                 {
22951                         r, err := zlib.NewReader(byteReader{r})
22952                         chk(err)
22953                         switch ver := read8(r); ver {
22954                         case 0:
22955                                 *p = nil
22956                         case 2:
22957                                 n := read16(r)
22958                                 *p = make(map[uint16]*NodeMeta, n)
22959                                 for ; n > 0; n-- {
22960                                         pos := read16(r)
22961                                         nm := new(NodeMeta)
22962                                         chk(deserialize(r, nm))
22963                                         (*p)[pos] = nm
22964                                 }
22965                         default:
22966                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
22967                         }
22968                         chk(r.Close())
22969                 }
22970         }
22971         {
22972                 var local290 uint8
22973                 local291 := uint8(2) // version
22974                 {
22975                         p := &local290
22976                         *p = read8(r)
22977                 }
22978                 if local290 != local291 {
22979                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local290))
22980                 }
22981         }
22982 }
22983
22984 func (obj *Node) serialize(w io.Writer) {
22985         if err := pcall(func() {
22986                 ((*(*(struct {
22987                         Param0         Content
22988                         Param1, Param2 uint8
22989                 }))(obj)).Param0).serialize(w)
22990         }); err != nil {
22991                 if err == io.EOF {
22992                         chk(io.EOF)
22993                 }
22994                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
22995         }
22996         {
22997                 x := (*(*(struct {
22998                         Param0         Content
22999                         Param1, Param2 uint8
23000                 }))(obj)).Param1
23001                 write8(w, uint8(x))
23002         }
23003         {
23004                 x := (*(*(struct {
23005                         Param0         Content
23006                         Param1, Param2 uint8
23007                 }))(obj)).Param2
23008                 write8(w, uint8(x))
23009         }
23010 }
23011
23012 func (obj *Node) deserialize(r io.Reader) {
23013         if err := pcall(func() {
23014                 ((*(*(struct {
23015                         Param0         Content
23016                         Param1, Param2 uint8
23017                 }))(obj)).Param0).deserialize(r)
23018         }); err != nil {
23019                 if err == io.EOF {
23020                         chk(io.EOF)
23021                 }
23022                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
23023         }
23024         {
23025                 p := &(*(*(struct {
23026                         Param0         Content
23027                         Param1, Param2 uint8
23028                 }))(obj)).Param1
23029                 *p = read8(r)
23030         }
23031         {
23032                 p := &(*(*(struct {
23033                         Param0         Content
23034                         Param1, Param2 uint8
23035                 }))(obj)).Param2
23036                 *p = read8(r)
23037         }
23038 }
23039
23040 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
23041         {
23042                 x := *(*(uint64))(obj)
23043                 write64(w, uint64(x))
23044         }
23045 }
23046
23047 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
23048         {
23049                 p := &*(*(uint64))(obj)
23050                 *p = read64(r)
23051         }
23052 }
23053
23054 func (obj *Vec) serialize(w io.Writer) {
23055         for local292 := range *(*([3]float32))(obj) {
23056                 {
23057                         x := (*(*([3]float32))(obj))[local292]
23058                         write32(w, math.Float32bits(x))
23059                 }
23060         }
23061 }
23062
23063 func (obj *Vec) deserialize(r io.Reader) {
23064         for local293 := range *(*([3]float32))(obj) {
23065                 {
23066                         p := &(*(*([3]float32))(obj))[local293]
23067                         *p = math.Float32frombits(read32(r))
23068                 }
23069         }
23070 }
23071
23072 func (obj *ChatMsgType) serialize(w io.Writer) {
23073         {
23074                 x := *(*(uint8))(obj)
23075                 write8(w, uint8(x))
23076         }
23077 }
23078
23079 func (obj *ChatMsgType) deserialize(r io.Reader) {
23080         {
23081                 p := &*(*(uint8))(obj)
23082                 *p = read8(r)
23083         }
23084 }
23085
23086 func (obj *AOID) serialize(w io.Writer) {
23087         {
23088                 x := *(*(uint16))(obj)
23089                 write16(w, uint16(x))
23090         }
23091 }
23092
23093 func (obj *AOID) deserialize(r io.Reader) {
23094         {
23095                 p := &*(*(uint16))(obj)
23096                 *p = read16(r)
23097         }
23098 }
23099
23100 func (obj *AOAdd) serialize(w io.Writer) {
23101         if err := pcall(func() {
23102                 ((*(*(struct {
23103                         ID AOID
23104                         //mt:const genericCAO
23105                         //mt:lenhdr 32
23106                         InitData AOInitData
23107                 }))(obj)).ID).serialize(w)
23108         }); err != nil {
23109                 if err == io.EOF {
23110                         chk(io.EOF)
23111                 }
23112                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23113         }
23114         {
23115                 local294 := genericCAO
23116                 if err := pcall(func() {
23117                         (local294).serialize(w)
23118                 }); err != nil {
23119                         if err == io.EOF {
23120                                 chk(io.EOF)
23121                         }
23122                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
23123                 }
23124         }
23125         {
23126                 ow := w
23127                 w := new(bytes.Buffer)
23128                 if err := pcall(func() {
23129                         ((*(*(struct {
23130                                 ID AOID
23131                                 //mt:const genericCAO
23132                                 //mt:lenhdr 32
23133                                 InitData AOInitData
23134                         }))(obj)).InitData).serialize(w)
23135                 }); err != nil {
23136                         if err == io.EOF {
23137                                 chk(io.EOF)
23138                         }
23139                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOInitData", err))
23140                 }
23141                 {
23142                         buf := w
23143                         w := ow
23144                         if len((buf.Bytes())) > math.MaxUint32 {
23145                                 chk(ErrTooLong)
23146                         }
23147                         {
23148                                 x := uint32(len((buf.Bytes())))
23149                                 write32(w, uint32(x))
23150                         }
23151                         {
23152                                 _, err := w.Write((buf.Bytes())[:])
23153                                 chk(err)
23154                         }
23155                 }
23156         }
23157 }
23158
23159 func (obj *AOAdd) deserialize(r io.Reader) {
23160         if err := pcall(func() {
23161                 ((*(*(struct {
23162                         ID AOID
23163                         //mt:const genericCAO
23164                         //mt:lenhdr 32
23165                         InitData AOInitData
23166                 }))(obj)).ID).deserialize(r)
23167         }); err != nil {
23168                 if err == io.EOF {
23169                         chk(io.EOF)
23170                 }
23171                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23172         }
23173         {
23174                 var local295 aoType
23175                 local296 := genericCAO
23176                 if err := pcall(func() {
23177                         (local295).deserialize(r)
23178                 }); err != nil {
23179                         if err == io.EOF {
23180                                 chk(io.EOF)
23181                         }
23182                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
23183                 }
23184                 if local295 != local296 {
23185                         chk(fmt.Errorf("const %v: %v", "genericCAO", local295))
23186                 }
23187         }
23188         {
23189                 var n uint32
23190                 {
23191                         p := &n
23192                         *p = read32(r)
23193                 }
23194                 r := &io.LimitedReader{R: r, N: int64(n)}
23195                 if err := pcall(func() {
23196                         ((*(*(struct {
23197                                 ID AOID
23198                                 //mt:const genericCAO
23199                                 //mt:lenhdr 32
23200                                 InitData AOInitData
23201                         }))(obj)).InitData).deserialize(r)
23202                 }); err != nil {
23203                         if err == io.EOF {
23204                                 chk(io.EOF)
23205                         }
23206                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOInitData", err))
23207                 }
23208                 if r.N > 0 {
23209                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23210                 }
23211         }
23212 }
23213
23214 func (obj *IDAOMsg) serialize(w io.Writer) {
23215         if err := pcall(func() {
23216                 ((*(*(struct {
23217                         ID AOID
23218                         //mt:lenhdr 16
23219                         Msg AOMsg
23220                 }))(obj)).ID).serialize(w)
23221         }); err != nil {
23222                 if err == io.EOF {
23223                         chk(io.EOF)
23224                 }
23225                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23226         }
23227         {
23228                 ow := w
23229                 w := new(bytes.Buffer)
23230                 {
23231                         x := (*(*(struct {
23232                                 ID AOID
23233                                 //mt:lenhdr 16
23234                                 Msg AOMsg
23235                         }))(obj)).Msg
23236                         writeAOMsg(w, x)
23237                 }
23238                 {
23239                         buf := w
23240                         w := ow
23241                         if len((buf.Bytes())) > math.MaxUint16 {
23242                                 chk(ErrTooLong)
23243                         }
23244                         {
23245                                 x := uint16(len((buf.Bytes())))
23246                                 write16(w, uint16(x))
23247                         }
23248                         {
23249                                 _, err := w.Write((buf.Bytes())[:])
23250                                 chk(err)
23251                         }
23252                 }
23253         }
23254 }
23255
23256 func (obj *IDAOMsg) deserialize(r io.Reader) {
23257         if err := pcall(func() {
23258                 ((*(*(struct {
23259                         ID AOID
23260                         //mt:lenhdr 16
23261                         Msg AOMsg
23262                 }))(obj)).ID).deserialize(r)
23263         }); err != nil {
23264                 if err == io.EOF {
23265                         chk(io.EOF)
23266                 }
23267                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23268         }
23269         {
23270                 var n uint16
23271                 {
23272                         p := &n
23273                         *p = read16(r)
23274                 }
23275                 r := &io.LimitedReader{R: r, N: int64(n)}
23276                 {
23277                         p := &(*(*(struct {
23278                                 ID AOID
23279                                 //mt:lenhdr 16
23280                                 Msg AOMsg
23281                         }))(obj)).Msg
23282                         {
23283                                 var err error
23284                                 *p, err = readAOMsg(r)
23285                                 chk(err)
23286                         }
23287                 }
23288                 if r.N > 0 {
23289                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23290                 }
23291         }
23292 }
23293
23294 func (obj *ItemDef) serialize(w io.Writer) {
23295         {
23296                 ow := w
23297                 w := new(bytes.Buffer)
23298                 {
23299                         local297 := uint8(6)
23300                         {
23301                                 x := local297
23302                                 write8(w, uint8(x))
23303                         }
23304                 }
23305                 if err := pcall(func() {
23306                         ((*(*(struct {
23307                                 Type ItemType
23308
23309                                 Name, Desc string
23310
23311                                 InvImg, WieldImg Texture
23312                                 WieldScale       [3]float32
23313
23314                                 StackMax uint16
23315
23316                                 Usable          bool
23317                                 CanPointLiquids bool
23318
23319                                 ToolCaps ToolCaps
23320
23321                                 Groups []Group
23322
23323                                 PlacePredict string
23324
23325                                 PlaceSnd, PlaceFailSnd SoundDef
23326
23327                                 PointRange float32
23328
23329                                 // Set index in Palette with "palette_index" item meta field,
23330                                 // this overrides Color.
23331                                 Palette Texture
23332                                 Color   color.NRGBA
23333
23334                                 // Texture overlays.
23335                                 InvOverlay, WieldOverlay Texture
23336
23337                                 ShortDesc string
23338                         }))(obj)).Type).serialize(w)
23339                 }); err != nil {
23340                         if err == io.EOF {
23341                                 chk(io.EOF)
23342                         }
23343                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemType", err))
23344                 }
23345                 if len(([]byte((*(*(struct {
23346                         Type ItemType
23347
23348                         Name, Desc string
23349
23350                         InvImg, WieldImg Texture
23351                         WieldScale       [3]float32
23352
23353                         StackMax uint16
23354
23355                         Usable          bool
23356                         CanPointLiquids bool
23357
23358                         ToolCaps ToolCaps
23359
23360                         Groups []Group
23361
23362                         PlacePredict string
23363
23364                         PlaceSnd, PlaceFailSnd SoundDef
23365
23366                         PointRange float32
23367
23368                         // Set index in Palette with "palette_index" item meta field,
23369                         // this overrides Color.
23370                         Palette Texture
23371                         Color   color.NRGBA
23372
23373                         // Texture overlays.
23374                         InvOverlay, WieldOverlay Texture
23375
23376                         ShortDesc string
23377                 }))(obj)).Name))) > math.MaxUint16 {
23378                         chk(ErrTooLong)
23379                 }
23380                 {
23381                         x := uint16(len(([]byte((*(*(struct {
23382                                 Type ItemType
23383
23384                                 Name, Desc string
23385
23386                                 InvImg, WieldImg Texture
23387                                 WieldScale       [3]float32
23388
23389                                 StackMax uint16
23390
23391                                 Usable          bool
23392                                 CanPointLiquids bool
23393
23394                                 ToolCaps ToolCaps
23395
23396                                 Groups []Group
23397
23398                                 PlacePredict string
23399
23400                                 PlaceSnd, PlaceFailSnd SoundDef
23401
23402                                 PointRange float32
23403
23404                                 // Set index in Palette with "palette_index" item meta field,
23405                                 // this overrides Color.
23406                                 Palette Texture
23407                                 Color   color.NRGBA
23408
23409                                 // Texture overlays.
23410                                 InvOverlay, WieldOverlay Texture
23411
23412                                 ShortDesc string
23413                         }))(obj)).Name))))
23414                         write16(w, uint16(x))
23415                 }
23416                 {
23417                         _, err := w.Write(([]byte((*(*(struct {
23418                                 Type ItemType
23419
23420                                 Name, Desc string
23421
23422                                 InvImg, WieldImg Texture
23423                                 WieldScale       [3]float32
23424
23425                                 StackMax uint16
23426
23427                                 Usable          bool
23428                                 CanPointLiquids bool
23429
23430                                 ToolCaps ToolCaps
23431
23432                                 Groups []Group
23433
23434                                 PlacePredict string
23435
23436                                 PlaceSnd, PlaceFailSnd SoundDef
23437
23438                                 PointRange float32
23439
23440                                 // Set index in Palette with "palette_index" item meta field,
23441                                 // this overrides Color.
23442                                 Palette Texture
23443                                 Color   color.NRGBA
23444
23445                                 // Texture overlays.
23446                                 InvOverlay, WieldOverlay Texture
23447
23448                                 ShortDesc string
23449                         }))(obj)).Name))[:])
23450                         chk(err)
23451                 }
23452                 if len(([]byte((*(*(struct {
23453                         Type ItemType
23454
23455                         Name, Desc string
23456
23457                         InvImg, WieldImg Texture
23458                         WieldScale       [3]float32
23459
23460                         StackMax uint16
23461
23462                         Usable          bool
23463                         CanPointLiquids bool
23464
23465                         ToolCaps ToolCaps
23466
23467                         Groups []Group
23468
23469                         PlacePredict string
23470
23471                         PlaceSnd, PlaceFailSnd SoundDef
23472
23473                         PointRange float32
23474
23475                         // Set index in Palette with "palette_index" item meta field,
23476                         // this overrides Color.
23477                         Palette Texture
23478                         Color   color.NRGBA
23479
23480                         // Texture overlays.
23481                         InvOverlay, WieldOverlay Texture
23482
23483                         ShortDesc string
23484                 }))(obj)).Desc))) > math.MaxUint16 {
23485                         chk(ErrTooLong)
23486                 }
23487                 {
23488                         x := uint16(len(([]byte((*(*(struct {
23489                                 Type ItemType
23490
23491                                 Name, Desc string
23492
23493                                 InvImg, WieldImg Texture
23494                                 WieldScale       [3]float32
23495
23496                                 StackMax uint16
23497
23498                                 Usable          bool
23499                                 CanPointLiquids bool
23500
23501                                 ToolCaps ToolCaps
23502
23503                                 Groups []Group
23504
23505                                 PlacePredict string
23506
23507                                 PlaceSnd, PlaceFailSnd SoundDef
23508
23509                                 PointRange float32
23510
23511                                 // Set index in Palette with "palette_index" item meta field,
23512                                 // this overrides Color.
23513                                 Palette Texture
23514                                 Color   color.NRGBA
23515
23516                                 // Texture overlays.
23517                                 InvOverlay, WieldOverlay Texture
23518
23519                                 ShortDesc string
23520                         }))(obj)).Desc))))
23521                         write16(w, uint16(x))
23522                 }
23523                 {
23524                         _, err := w.Write(([]byte((*(*(struct {
23525                                 Type ItemType
23526
23527                                 Name, Desc string
23528
23529                                 InvImg, WieldImg Texture
23530                                 WieldScale       [3]float32
23531
23532                                 StackMax uint16
23533
23534                                 Usable          bool
23535                                 CanPointLiquids bool
23536
23537                                 ToolCaps ToolCaps
23538
23539                                 Groups []Group
23540
23541                                 PlacePredict string
23542
23543                                 PlaceSnd, PlaceFailSnd SoundDef
23544
23545                                 PointRange float32
23546
23547                                 // Set index in Palette with "palette_index" item meta field,
23548                                 // this overrides Color.
23549                                 Palette Texture
23550                                 Color   color.NRGBA
23551
23552                                 // Texture overlays.
23553                                 InvOverlay, WieldOverlay Texture
23554
23555                                 ShortDesc string
23556                         }))(obj)).Desc))[:])
23557                         chk(err)
23558                 }
23559                 if err := pcall(func() {
23560                         ((*(*(struct {
23561                                 Type ItemType
23562
23563                                 Name, Desc string
23564
23565                                 InvImg, WieldImg Texture
23566                                 WieldScale       [3]float32
23567
23568                                 StackMax uint16
23569
23570                                 Usable          bool
23571                                 CanPointLiquids bool
23572
23573                                 ToolCaps ToolCaps
23574
23575                                 Groups []Group
23576
23577                                 PlacePredict string
23578
23579                                 PlaceSnd, PlaceFailSnd SoundDef
23580
23581                                 PointRange float32
23582
23583                                 // Set index in Palette with "palette_index" item meta field,
23584                                 // this overrides Color.
23585                                 Palette Texture
23586                                 Color   color.NRGBA
23587
23588                                 // Texture overlays.
23589                                 InvOverlay, WieldOverlay Texture
23590
23591                                 ShortDesc string
23592                         }))(obj)).InvImg).serialize(w)
23593                 }); err != nil {
23594                         if err == io.EOF {
23595                                 chk(io.EOF)
23596                         }
23597                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
23598                 }
23599                 if err := pcall(func() {
23600                         ((*(*(struct {
23601                                 Type ItemType
23602
23603                                 Name, Desc string
23604
23605                                 InvImg, WieldImg Texture
23606                                 WieldScale       [3]float32
23607
23608                                 StackMax uint16
23609
23610                                 Usable          bool
23611                                 CanPointLiquids bool
23612
23613                                 ToolCaps ToolCaps
23614
23615                                 Groups []Group
23616
23617                                 PlacePredict string
23618
23619                                 PlaceSnd, PlaceFailSnd SoundDef
23620
23621                                 PointRange float32
23622
23623                                 // Set index in Palette with "palette_index" item meta field,
23624                                 // this overrides Color.
23625                                 Palette Texture
23626                                 Color   color.NRGBA
23627
23628                                 // Texture overlays.
23629                                 InvOverlay, WieldOverlay Texture
23630
23631                                 ShortDesc string
23632                         }))(obj)).WieldImg).serialize(w)
23633                 }); err != nil {
23634                         if err == io.EOF {
23635                                 chk(io.EOF)
23636                         }
23637                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
23638                 }
23639                 for local298 := range (*(*(struct {
23640                         Type ItemType
23641
23642                         Name, Desc string
23643
23644                         InvImg, WieldImg Texture
23645                         WieldScale       [3]float32
23646
23647                         StackMax uint16
23648
23649                         Usable          bool
23650                         CanPointLiquids bool
23651
23652                         ToolCaps ToolCaps
23653
23654                         Groups []Group
23655
23656                         PlacePredict string
23657
23658                         PlaceSnd, PlaceFailSnd SoundDef
23659
23660                         PointRange float32
23661
23662                         // Set index in Palette with "palette_index" item meta field,
23663                         // this overrides Color.
23664                         Palette Texture
23665                         Color   color.NRGBA
23666
23667                         // Texture overlays.
23668                         InvOverlay, WieldOverlay Texture
23669
23670                         ShortDesc string
23671                 }))(obj)).WieldScale {
23672                         {
23673                                 x := ((*(*(struct {
23674                                         Type ItemType
23675
23676                                         Name, Desc string
23677
23678                                         InvImg, WieldImg Texture
23679                                         WieldScale       [3]float32
23680
23681                                         StackMax uint16
23682
23683                                         Usable          bool
23684                                         CanPointLiquids bool
23685
23686                                         ToolCaps ToolCaps
23687
23688                                         Groups []Group
23689
23690                                         PlacePredict string
23691
23692                                         PlaceSnd, PlaceFailSnd SoundDef
23693
23694                                         PointRange float32
23695
23696                                         // Set index in Palette with "palette_index" item meta field,
23697                                         // this overrides Color.
23698                                         Palette Texture
23699                                         Color   color.NRGBA
23700
23701                                         // Texture overlays.
23702                                         InvOverlay, WieldOverlay Texture
23703
23704                                         ShortDesc string
23705                                 }))(obj)).WieldScale)[local298]
23706                                 write32(w, math.Float32bits(x))
23707                         }
23708                 }
23709                 {
23710                         x := (*(*(struct {
23711                                 Type ItemType
23712
23713                                 Name, Desc string
23714
23715                                 InvImg, WieldImg Texture
23716                                 WieldScale       [3]float32
23717
23718                                 StackMax uint16
23719
23720                                 Usable          bool
23721                                 CanPointLiquids bool
23722
23723                                 ToolCaps ToolCaps
23724
23725                                 Groups []Group
23726
23727                                 PlacePredict string
23728
23729                                 PlaceSnd, PlaceFailSnd SoundDef
23730
23731                                 PointRange float32
23732
23733                                 // Set index in Palette with "palette_index" item meta field,
23734                                 // this overrides Color.
23735                                 Palette Texture
23736                                 Color   color.NRGBA
23737
23738                                 // Texture overlays.
23739                                 InvOverlay, WieldOverlay Texture
23740
23741                                 ShortDesc string
23742                         }))(obj)).StackMax
23743                         write16(w, uint16(x))
23744                 }
23745                 {
23746                         x := (*(*(struct {
23747                                 Type ItemType
23748
23749                                 Name, Desc string
23750
23751                                 InvImg, WieldImg Texture
23752                                 WieldScale       [3]float32
23753
23754                                 StackMax uint16
23755
23756                                 Usable          bool
23757                                 CanPointLiquids bool
23758
23759                                 ToolCaps ToolCaps
23760
23761                                 Groups []Group
23762
23763                                 PlacePredict string
23764
23765                                 PlaceSnd, PlaceFailSnd SoundDef
23766
23767                                 PointRange float32
23768
23769                                 // Set index in Palette with "palette_index" item meta field,
23770                                 // this overrides Color.
23771                                 Palette Texture
23772                                 Color   color.NRGBA
23773
23774                                 // Texture overlays.
23775                                 InvOverlay, WieldOverlay Texture
23776
23777                                 ShortDesc string
23778                         }))(obj)).Usable
23779                         if x {
23780                                 write8(w, 1)
23781                         } else {
23782                                 write8(w, 0)
23783                         }
23784                 }
23785                 {
23786                         x := (*(*(struct {
23787                                 Type ItemType
23788
23789                                 Name, Desc string
23790
23791                                 InvImg, WieldImg Texture
23792                                 WieldScale       [3]float32
23793
23794                                 StackMax uint16
23795
23796                                 Usable          bool
23797                                 CanPointLiquids bool
23798
23799                                 ToolCaps ToolCaps
23800
23801                                 Groups []Group
23802
23803                                 PlacePredict string
23804
23805                                 PlaceSnd, PlaceFailSnd SoundDef
23806
23807                                 PointRange float32
23808
23809                                 // Set index in Palette with "palette_index" item meta field,
23810                                 // this overrides Color.
23811                                 Palette Texture
23812                                 Color   color.NRGBA
23813
23814                                 // Texture overlays.
23815                                 InvOverlay, WieldOverlay Texture
23816
23817                                 ShortDesc string
23818                         }))(obj)).CanPointLiquids
23819                         if x {
23820                                 write8(w, 1)
23821                         } else {
23822                                 write8(w, 0)
23823                         }
23824                 }
23825                 if err := pcall(func() {
23826                         ((*(*(struct {
23827                                 Type ItemType
23828
23829                                 Name, Desc string
23830
23831                                 InvImg, WieldImg Texture
23832                                 WieldScale       [3]float32
23833
23834                                 StackMax uint16
23835
23836                                 Usable          bool
23837                                 CanPointLiquids bool
23838
23839                                 ToolCaps ToolCaps
23840
23841                                 Groups []Group
23842
23843                                 PlacePredict string
23844
23845                                 PlaceSnd, PlaceFailSnd SoundDef
23846
23847                                 PointRange float32
23848
23849                                 // Set index in Palette with "palette_index" item meta field,
23850                                 // this overrides Color.
23851                                 Palette Texture
23852                                 Color   color.NRGBA
23853
23854                                 // Texture overlays.
23855                                 InvOverlay, WieldOverlay Texture
23856
23857                                 ShortDesc string
23858                         }))(obj)).ToolCaps).serialize(w)
23859                 }); err != nil {
23860                         if err == io.EOF {
23861                                 chk(io.EOF)
23862                         }
23863                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolCaps", err))
23864                 }
23865                 if len(((*(*(struct {
23866                         Type ItemType
23867
23868                         Name, Desc string
23869
23870                         InvImg, WieldImg Texture
23871                         WieldScale       [3]float32
23872
23873                         StackMax uint16
23874
23875                         Usable          bool
23876                         CanPointLiquids bool
23877
23878                         ToolCaps ToolCaps
23879
23880                         Groups []Group
23881
23882                         PlacePredict string
23883
23884                         PlaceSnd, PlaceFailSnd SoundDef
23885
23886                         PointRange float32
23887
23888                         // Set index in Palette with "palette_index" item meta field,
23889                         // this overrides Color.
23890                         Palette Texture
23891                         Color   color.NRGBA
23892
23893                         // Texture overlays.
23894                         InvOverlay, WieldOverlay Texture
23895
23896                         ShortDesc string
23897                 }))(obj)).Groups)) > math.MaxUint16 {
23898                         chk(ErrTooLong)
23899                 }
23900                 {
23901                         x := uint16(len(((*(*(struct {
23902                                 Type ItemType
23903
23904                                 Name, Desc string
23905
23906                                 InvImg, WieldImg Texture
23907                                 WieldScale       [3]float32
23908
23909                                 StackMax uint16
23910
23911                                 Usable          bool
23912                                 CanPointLiquids bool
23913
23914                                 ToolCaps ToolCaps
23915
23916                                 Groups []Group
23917
23918                                 PlacePredict string
23919
23920                                 PlaceSnd, PlaceFailSnd SoundDef
23921
23922                                 PointRange float32
23923
23924                                 // Set index in Palette with "palette_index" item meta field,
23925                                 // this overrides Color.
23926                                 Palette Texture
23927                                 Color   color.NRGBA
23928
23929                                 // Texture overlays.
23930                                 InvOverlay, WieldOverlay Texture
23931
23932                                 ShortDesc string
23933                         }))(obj)).Groups)))
23934                         write16(w, uint16(x))
23935                 }
23936                 for local299 := range (*(*(struct {
23937                         Type ItemType
23938
23939                         Name, Desc string
23940
23941                         InvImg, WieldImg Texture
23942                         WieldScale       [3]float32
23943
23944                         StackMax uint16
23945
23946                         Usable          bool
23947                         CanPointLiquids bool
23948
23949                         ToolCaps ToolCaps
23950
23951                         Groups []Group
23952
23953                         PlacePredict string
23954
23955                         PlaceSnd, PlaceFailSnd SoundDef
23956
23957                         PointRange float32
23958
23959                         // Set index in Palette with "palette_index" item meta field,
23960                         // this overrides Color.
23961                         Palette Texture
23962                         Color   color.NRGBA
23963
23964                         // Texture overlays.
23965                         InvOverlay, WieldOverlay Texture
23966
23967                         ShortDesc string
23968                 }))(obj)).Groups {
23969                         if err := pcall(func() {
23970                                 (((*(*(struct {
23971                                         Type ItemType
23972
23973                                         Name, Desc string
23974
23975                                         InvImg, WieldImg Texture
23976                                         WieldScale       [3]float32
23977
23978                                         StackMax uint16
23979
23980                                         Usable          bool
23981                                         CanPointLiquids bool
23982
23983                                         ToolCaps ToolCaps
23984
23985                                         Groups []Group
23986
23987                                         PlacePredict string
23988
23989                                         PlaceSnd, PlaceFailSnd SoundDef
23990
23991                                         PointRange float32
23992
23993                                         // Set index in Palette with "palette_index" item meta field,
23994                                         // this overrides Color.
23995                                         Palette Texture
23996                                         Color   color.NRGBA
23997
23998                                         // Texture overlays.
23999                                         InvOverlay, WieldOverlay Texture
24000
24001                                         ShortDesc string
24002                                 }))(obj)).Groups)[local299]).serialize(w)
24003                         }); err != nil {
24004                                 if err == io.EOF {
24005                                         chk(io.EOF)
24006                                 }
24007                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
24008                         }
24009                 }
24010                 if len(([]byte((*(*(struct {
24011                         Type ItemType
24012
24013                         Name, Desc string
24014
24015                         InvImg, WieldImg Texture
24016                         WieldScale       [3]float32
24017
24018                         StackMax uint16
24019
24020                         Usable          bool
24021                         CanPointLiquids bool
24022
24023                         ToolCaps ToolCaps
24024
24025                         Groups []Group
24026
24027                         PlacePredict string
24028
24029                         PlaceSnd, PlaceFailSnd SoundDef
24030
24031                         PointRange float32
24032
24033                         // Set index in Palette with "palette_index" item meta field,
24034                         // this overrides Color.
24035                         Palette Texture
24036                         Color   color.NRGBA
24037
24038                         // Texture overlays.
24039                         InvOverlay, WieldOverlay Texture
24040
24041                         ShortDesc string
24042                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24043                         chk(ErrTooLong)
24044                 }
24045                 {
24046                         x := uint16(len(([]byte((*(*(struct {
24047                                 Type ItemType
24048
24049                                 Name, Desc string
24050
24051                                 InvImg, WieldImg Texture
24052                                 WieldScale       [3]float32
24053
24054                                 StackMax uint16
24055
24056                                 Usable          bool
24057                                 CanPointLiquids bool
24058
24059                                 ToolCaps ToolCaps
24060
24061                                 Groups []Group
24062
24063                                 PlacePredict string
24064
24065                                 PlaceSnd, PlaceFailSnd SoundDef
24066
24067                                 PointRange float32
24068
24069                                 // Set index in Palette with "palette_index" item meta field,
24070                                 // this overrides Color.
24071                                 Palette Texture
24072                                 Color   color.NRGBA
24073
24074                                 // Texture overlays.
24075                                 InvOverlay, WieldOverlay Texture
24076
24077                                 ShortDesc string
24078                         }))(obj)).PlacePredict))))
24079                         write16(w, uint16(x))
24080                 }
24081                 {
24082                         _, err := w.Write(([]byte((*(*(struct {
24083                                 Type ItemType
24084
24085                                 Name, Desc string
24086
24087                                 InvImg, WieldImg Texture
24088                                 WieldScale       [3]float32
24089
24090                                 StackMax uint16
24091
24092                                 Usable          bool
24093                                 CanPointLiquids bool
24094
24095                                 ToolCaps ToolCaps
24096
24097                                 Groups []Group
24098
24099                                 PlacePredict string
24100
24101                                 PlaceSnd, PlaceFailSnd SoundDef
24102
24103                                 PointRange float32
24104
24105                                 // Set index in Palette with "palette_index" item meta field,
24106                                 // this overrides Color.
24107                                 Palette Texture
24108                                 Color   color.NRGBA
24109
24110                                 // Texture overlays.
24111                                 InvOverlay, WieldOverlay Texture
24112
24113                                 ShortDesc string
24114                         }))(obj)).PlacePredict))[:])
24115                         chk(err)
24116                 }
24117                 if err := pcall(func() {
24118                         ((*(*(struct {
24119                                 Type ItemType
24120
24121                                 Name, Desc string
24122
24123                                 InvImg, WieldImg Texture
24124                                 WieldScale       [3]float32
24125
24126                                 StackMax uint16
24127
24128                                 Usable          bool
24129                                 CanPointLiquids bool
24130
24131                                 ToolCaps ToolCaps
24132
24133                                 Groups []Group
24134
24135                                 PlacePredict string
24136
24137                                 PlaceSnd, PlaceFailSnd SoundDef
24138
24139                                 PointRange float32
24140
24141                                 // Set index in Palette with "palette_index" item meta field,
24142                                 // this overrides Color.
24143                                 Palette Texture
24144                                 Color   color.NRGBA
24145
24146                                 // Texture overlays.
24147                                 InvOverlay, WieldOverlay Texture
24148
24149                                 ShortDesc string
24150                         }))(obj)).PlaceSnd).serialize(w)
24151                 }); err != nil {
24152                         if err == io.EOF {
24153                                 chk(io.EOF)
24154                         }
24155                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
24156                 }
24157                 if err := pcall(func() {
24158                         ((*(*(struct {
24159                                 Type ItemType
24160
24161                                 Name, Desc string
24162
24163                                 InvImg, WieldImg Texture
24164                                 WieldScale       [3]float32
24165
24166                                 StackMax uint16
24167
24168                                 Usable          bool
24169                                 CanPointLiquids bool
24170
24171                                 ToolCaps ToolCaps
24172
24173                                 Groups []Group
24174
24175                                 PlacePredict string
24176
24177                                 PlaceSnd, PlaceFailSnd SoundDef
24178
24179                                 PointRange float32
24180
24181                                 // Set index in Palette with "palette_index" item meta field,
24182                                 // this overrides Color.
24183                                 Palette Texture
24184                                 Color   color.NRGBA
24185
24186                                 // Texture overlays.
24187                                 InvOverlay, WieldOverlay Texture
24188
24189                                 ShortDesc string
24190                         }))(obj)).PlaceFailSnd).serialize(w)
24191                 }); err != nil {
24192                         if err == io.EOF {
24193                                 chk(io.EOF)
24194                         }
24195                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
24196                 }
24197                 {
24198                         x := (*(*(struct {
24199                                 Type ItemType
24200
24201                                 Name, Desc string
24202
24203                                 InvImg, WieldImg Texture
24204                                 WieldScale       [3]float32
24205
24206                                 StackMax uint16
24207
24208                                 Usable          bool
24209                                 CanPointLiquids bool
24210
24211                                 ToolCaps ToolCaps
24212
24213                                 Groups []Group
24214
24215                                 PlacePredict string
24216
24217                                 PlaceSnd, PlaceFailSnd SoundDef
24218
24219                                 PointRange float32
24220
24221                                 // Set index in Palette with "palette_index" item meta field,
24222                                 // this overrides Color.
24223                                 Palette Texture
24224                                 Color   color.NRGBA
24225
24226                                 // Texture overlays.
24227                                 InvOverlay, WieldOverlay Texture
24228
24229                                 ShortDesc string
24230                         }))(obj)).PointRange
24231                         write32(w, math.Float32bits(x))
24232                 }
24233                 if err := pcall(func() {
24234                         ((*(*(struct {
24235                                 Type ItemType
24236
24237                                 Name, Desc string
24238
24239                                 InvImg, WieldImg Texture
24240                                 WieldScale       [3]float32
24241
24242                                 StackMax uint16
24243
24244                                 Usable          bool
24245                                 CanPointLiquids bool
24246
24247                                 ToolCaps ToolCaps
24248
24249                                 Groups []Group
24250
24251                                 PlacePredict string
24252
24253                                 PlaceSnd, PlaceFailSnd SoundDef
24254
24255                                 PointRange float32
24256
24257                                 // Set index in Palette with "palette_index" item meta field,
24258                                 // this overrides Color.
24259                                 Palette Texture
24260                                 Color   color.NRGBA
24261
24262                                 // Texture overlays.
24263                                 InvOverlay, WieldOverlay Texture
24264
24265                                 ShortDesc string
24266                         }))(obj)).Palette).serialize(w)
24267                 }); err != nil {
24268                         if err == io.EOF {
24269                                 chk(io.EOF)
24270                         }
24271                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24272                 }
24273                 {
24274                         x := (*(*(struct {
24275                                 Type ItemType
24276
24277                                 Name, Desc string
24278
24279                                 InvImg, WieldImg Texture
24280                                 WieldScale       [3]float32
24281
24282                                 StackMax uint16
24283
24284                                 Usable          bool
24285                                 CanPointLiquids bool
24286
24287                                 ToolCaps ToolCaps
24288
24289                                 Groups []Group
24290
24291                                 PlacePredict string
24292
24293                                 PlaceSnd, PlaceFailSnd SoundDef
24294
24295                                 PointRange float32
24296
24297                                 // Set index in Palette with "palette_index" item meta field,
24298                                 // this overrides Color.
24299                                 Palette Texture
24300                                 Color   color.NRGBA
24301
24302                                 // Texture overlays.
24303                                 InvOverlay, WieldOverlay Texture
24304
24305                                 ShortDesc string
24306                         }))(obj)).Color
24307                         w.Write([]byte{x.A, x.R, x.G, x.B})
24308                 }
24309                 if err := pcall(func() {
24310                         ((*(*(struct {
24311                                 Type ItemType
24312
24313                                 Name, Desc string
24314
24315                                 InvImg, WieldImg Texture
24316                                 WieldScale       [3]float32
24317
24318                                 StackMax uint16
24319
24320                                 Usable          bool
24321                                 CanPointLiquids bool
24322
24323                                 ToolCaps ToolCaps
24324
24325                                 Groups []Group
24326
24327                                 PlacePredict string
24328
24329                                 PlaceSnd, PlaceFailSnd SoundDef
24330
24331                                 PointRange float32
24332
24333                                 // Set index in Palette with "palette_index" item meta field,
24334                                 // this overrides Color.
24335                                 Palette Texture
24336                                 Color   color.NRGBA
24337
24338                                 // Texture overlays.
24339                                 InvOverlay, WieldOverlay Texture
24340
24341                                 ShortDesc string
24342                         }))(obj)).InvOverlay).serialize(w)
24343                 }); err != nil {
24344                         if err == io.EOF {
24345                                 chk(io.EOF)
24346                         }
24347                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24348                 }
24349                 if err := pcall(func() {
24350                         ((*(*(struct {
24351                                 Type ItemType
24352
24353                                 Name, Desc string
24354
24355                                 InvImg, WieldImg Texture
24356                                 WieldScale       [3]float32
24357
24358                                 StackMax uint16
24359
24360                                 Usable          bool
24361                                 CanPointLiquids bool
24362
24363                                 ToolCaps ToolCaps
24364
24365                                 Groups []Group
24366
24367                                 PlacePredict string
24368
24369                                 PlaceSnd, PlaceFailSnd SoundDef
24370
24371                                 PointRange float32
24372
24373                                 // Set index in Palette with "palette_index" item meta field,
24374                                 // this overrides Color.
24375                                 Palette Texture
24376                                 Color   color.NRGBA
24377
24378                                 // Texture overlays.
24379                                 InvOverlay, WieldOverlay Texture
24380
24381                                 ShortDesc string
24382                         }))(obj)).WieldOverlay).serialize(w)
24383                 }); err != nil {
24384                         if err == io.EOF {
24385                                 chk(io.EOF)
24386                         }
24387                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24388                 }
24389                 if len(([]byte((*(*(struct {
24390                         Type ItemType
24391
24392                         Name, Desc string
24393
24394                         InvImg, WieldImg Texture
24395                         WieldScale       [3]float32
24396
24397                         StackMax uint16
24398
24399                         Usable          bool
24400                         CanPointLiquids bool
24401
24402                         ToolCaps ToolCaps
24403
24404                         Groups []Group
24405
24406                         PlacePredict string
24407
24408                         PlaceSnd, PlaceFailSnd SoundDef
24409
24410                         PointRange float32
24411
24412                         // Set index in Palette with "palette_index" item meta field,
24413                         // this overrides Color.
24414                         Palette Texture
24415                         Color   color.NRGBA
24416
24417                         // Texture overlays.
24418                         InvOverlay, WieldOverlay Texture
24419
24420                         ShortDesc string
24421                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24422                         chk(ErrTooLong)
24423                 }
24424                 {
24425                         x := uint16(len(([]byte((*(*(struct {
24426                                 Type ItemType
24427
24428                                 Name, Desc string
24429
24430                                 InvImg, WieldImg Texture
24431                                 WieldScale       [3]float32
24432
24433                                 StackMax uint16
24434
24435                                 Usable          bool
24436                                 CanPointLiquids bool
24437
24438                                 ToolCaps ToolCaps
24439
24440                                 Groups []Group
24441
24442                                 PlacePredict string
24443
24444                                 PlaceSnd, PlaceFailSnd SoundDef
24445
24446                                 PointRange float32
24447
24448                                 // Set index in Palette with "palette_index" item meta field,
24449                                 // this overrides Color.
24450                                 Palette Texture
24451                                 Color   color.NRGBA
24452
24453                                 // Texture overlays.
24454                                 InvOverlay, WieldOverlay Texture
24455
24456                                 ShortDesc string
24457                         }))(obj)).ShortDesc))))
24458                         write16(w, uint16(x))
24459                 }
24460                 {
24461                         _, err := w.Write(([]byte((*(*(struct {
24462                                 Type ItemType
24463
24464                                 Name, Desc string
24465
24466                                 InvImg, WieldImg Texture
24467                                 WieldScale       [3]float32
24468
24469                                 StackMax uint16
24470
24471                                 Usable          bool
24472                                 CanPointLiquids bool
24473
24474                                 ToolCaps ToolCaps
24475
24476                                 Groups []Group
24477
24478                                 PlacePredict string
24479
24480                                 PlaceSnd, PlaceFailSnd SoundDef
24481
24482                                 PointRange float32
24483
24484                                 // Set index in Palette with "palette_index" item meta field,
24485                                 // this overrides Color.
24486                                 Palette Texture
24487                                 Color   color.NRGBA
24488
24489                                 // Texture overlays.
24490                                 InvOverlay, WieldOverlay Texture
24491
24492                                 ShortDesc string
24493                         }))(obj)).ShortDesc))[:])
24494                         chk(err)
24495                 }
24496                 {
24497                         buf := w
24498                         w := ow
24499                         if len((buf.Bytes())) > math.MaxUint16 {
24500                                 chk(ErrTooLong)
24501                         }
24502                         {
24503                                 x := uint16(len((buf.Bytes())))
24504                                 write16(w, uint16(x))
24505                         }
24506                         {
24507                                 _, err := w.Write((buf.Bytes())[:])
24508                                 chk(err)
24509                         }
24510                 }
24511         }
24512 }
24513
24514 func (obj *ItemDef) deserialize(r io.Reader) {
24515         {
24516                 var n uint16
24517                 {
24518                         p := &n
24519                         *p = read16(r)
24520                 }
24521                 r := &io.LimitedReader{R: r, N: int64(n)}
24522                 {
24523                         var local300 uint8
24524                         local301 := uint8(6)
24525                         {
24526                                 p := &local300
24527                                 *p = read8(r)
24528                         }
24529                         if local300 != local301 {
24530                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local300))
24531                         }
24532                 }
24533                 if err := pcall(func() {
24534                         ((*(*(struct {
24535                                 Type ItemType
24536
24537                                 Name, Desc string
24538
24539                                 InvImg, WieldImg Texture
24540                                 WieldScale       [3]float32
24541
24542                                 StackMax uint16
24543
24544                                 Usable          bool
24545                                 CanPointLiquids bool
24546
24547                                 ToolCaps ToolCaps
24548
24549                                 Groups []Group
24550
24551                                 PlacePredict string
24552
24553                                 PlaceSnd, PlaceFailSnd SoundDef
24554
24555                                 PointRange float32
24556
24557                                 // Set index in Palette with "palette_index" item meta field,
24558                                 // this overrides Color.
24559                                 Palette Texture
24560                                 Color   color.NRGBA
24561
24562                                 // Texture overlays.
24563                                 InvOverlay, WieldOverlay Texture
24564
24565                                 ShortDesc string
24566                         }))(obj)).Type).deserialize(r)
24567                 }); err != nil {
24568                         if err == io.EOF {
24569                                 chk(io.EOF)
24570                         }
24571                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemType", err))
24572                 }
24573                 var local302 []uint8
24574                 var local303 uint16
24575                 {
24576                         p := &local303
24577                         *p = read16(r)
24578                 }
24579                 (local302) = make([]uint8, local303)
24580                 {
24581                         _, err := io.ReadFull(r, (local302)[:])
24582                         chk(err)
24583                 }
24584                 ((*(*(struct {
24585                         Type ItemType
24586
24587                         Name, Desc string
24588
24589                         InvImg, WieldImg Texture
24590                         WieldScale       [3]float32
24591
24592                         StackMax uint16
24593
24594                         Usable          bool
24595                         CanPointLiquids bool
24596
24597                         ToolCaps ToolCaps
24598
24599                         Groups []Group
24600
24601                         PlacePredict string
24602
24603                         PlaceSnd, PlaceFailSnd SoundDef
24604
24605                         PointRange float32
24606
24607                         // Set index in Palette with "palette_index" item meta field,
24608                         // this overrides Color.
24609                         Palette Texture
24610                         Color   color.NRGBA
24611
24612                         // Texture overlays.
24613                         InvOverlay, WieldOverlay Texture
24614
24615                         ShortDesc string
24616                 }))(obj)).Name) = string(local302)
24617                 var local304 []uint8
24618                 var local305 uint16
24619                 {
24620                         p := &local305
24621                         *p = read16(r)
24622                 }
24623                 (local304) = make([]uint8, local305)
24624                 {
24625                         _, err := io.ReadFull(r, (local304)[:])
24626                         chk(err)
24627                 }
24628                 ((*(*(struct {
24629                         Type ItemType
24630
24631                         Name, Desc string
24632
24633                         InvImg, WieldImg Texture
24634                         WieldScale       [3]float32
24635
24636                         StackMax uint16
24637
24638                         Usable          bool
24639                         CanPointLiquids bool
24640
24641                         ToolCaps ToolCaps
24642
24643                         Groups []Group
24644
24645                         PlacePredict string
24646
24647                         PlaceSnd, PlaceFailSnd SoundDef
24648
24649                         PointRange float32
24650
24651                         // Set index in Palette with "palette_index" item meta field,
24652                         // this overrides Color.
24653                         Palette Texture
24654                         Color   color.NRGBA
24655
24656                         // Texture overlays.
24657                         InvOverlay, WieldOverlay Texture
24658
24659                         ShortDesc string
24660                 }))(obj)).Desc) = string(local304)
24661                 if err := pcall(func() {
24662                         ((*(*(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)).InvImg).deserialize(r)
24695                 }); err != nil {
24696                         if err == io.EOF {
24697                                 chk(io.EOF)
24698                         }
24699                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24700                 }
24701                 if err := pcall(func() {
24702                         ((*(*(struct {
24703                                 Type ItemType
24704
24705                                 Name, Desc string
24706
24707                                 InvImg, WieldImg Texture
24708                                 WieldScale       [3]float32
24709
24710                                 StackMax uint16
24711
24712                                 Usable          bool
24713                                 CanPointLiquids bool
24714
24715                                 ToolCaps ToolCaps
24716
24717                                 Groups []Group
24718
24719                                 PlacePredict string
24720
24721                                 PlaceSnd, PlaceFailSnd SoundDef
24722
24723                                 PointRange float32
24724
24725                                 // Set index in Palette with "palette_index" item meta field,
24726                                 // this overrides Color.
24727                                 Palette Texture
24728                                 Color   color.NRGBA
24729
24730                                 // Texture overlays.
24731                                 InvOverlay, WieldOverlay Texture
24732
24733                                 ShortDesc string
24734                         }))(obj)).WieldImg).deserialize(r)
24735                 }); err != nil {
24736                         if err == io.EOF {
24737                                 chk(io.EOF)
24738                         }
24739                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24740                 }
24741                 for local306 := range (*(*(struct {
24742                         Type ItemType
24743
24744                         Name, Desc string
24745
24746                         InvImg, WieldImg Texture
24747                         WieldScale       [3]float32
24748
24749                         StackMax uint16
24750
24751                         Usable          bool
24752                         CanPointLiquids bool
24753
24754                         ToolCaps ToolCaps
24755
24756                         Groups []Group
24757
24758                         PlacePredict string
24759
24760                         PlaceSnd, PlaceFailSnd SoundDef
24761
24762                         PointRange float32
24763
24764                         // Set index in Palette with "palette_index" item meta field,
24765                         // this overrides Color.
24766                         Palette Texture
24767                         Color   color.NRGBA
24768
24769                         // Texture overlays.
24770                         InvOverlay, WieldOverlay Texture
24771
24772                         ShortDesc string
24773                 }))(obj)).WieldScale {
24774                         {
24775                                 p := &((*(*(struct {
24776                                         Type ItemType
24777
24778                                         Name, Desc string
24779
24780                                         InvImg, WieldImg Texture
24781                                         WieldScale       [3]float32
24782
24783                                         StackMax uint16
24784
24785                                         Usable          bool
24786                                         CanPointLiquids bool
24787
24788                                         ToolCaps ToolCaps
24789
24790                                         Groups []Group
24791
24792                                         PlacePredict string
24793
24794                                         PlaceSnd, PlaceFailSnd SoundDef
24795
24796                                         PointRange float32
24797
24798                                         // Set index in Palette with "palette_index" item meta field,
24799                                         // this overrides Color.
24800                                         Palette Texture
24801                                         Color   color.NRGBA
24802
24803                                         // Texture overlays.
24804                                         InvOverlay, WieldOverlay Texture
24805
24806                                         ShortDesc string
24807                                 }))(obj)).WieldScale)[local306]
24808                                 *p = math.Float32frombits(read32(r))
24809                         }
24810                 }
24811                 {
24812                         p := &(*(*(struct {
24813                                 Type ItemType
24814
24815                                 Name, Desc string
24816
24817                                 InvImg, WieldImg Texture
24818                                 WieldScale       [3]float32
24819
24820                                 StackMax uint16
24821
24822                                 Usable          bool
24823                                 CanPointLiquids bool
24824
24825                                 ToolCaps ToolCaps
24826
24827                                 Groups []Group
24828
24829                                 PlacePredict string
24830
24831                                 PlaceSnd, PlaceFailSnd SoundDef
24832
24833                                 PointRange float32
24834
24835                                 // Set index in Palette with "palette_index" item meta field,
24836                                 // this overrides Color.
24837                                 Palette Texture
24838                                 Color   color.NRGBA
24839
24840                                 // Texture overlays.
24841                                 InvOverlay, WieldOverlay Texture
24842
24843                                 ShortDesc string
24844                         }))(obj)).StackMax
24845                         *p = read16(r)
24846                 }
24847                 {
24848                         p := &(*(*(struct {
24849                                 Type ItemType
24850
24851                                 Name, Desc string
24852
24853                                 InvImg, WieldImg Texture
24854                                 WieldScale       [3]float32
24855
24856                                 StackMax uint16
24857
24858                                 Usable          bool
24859                                 CanPointLiquids bool
24860
24861                                 ToolCaps ToolCaps
24862
24863                                 Groups []Group
24864
24865                                 PlacePredict string
24866
24867                                 PlaceSnd, PlaceFailSnd SoundDef
24868
24869                                 PointRange float32
24870
24871                                 // Set index in Palette with "palette_index" item meta field,
24872                                 // this overrides Color.
24873                                 Palette Texture
24874                                 Color   color.NRGBA
24875
24876                                 // Texture overlays.
24877                                 InvOverlay, WieldOverlay Texture
24878
24879                                 ShortDesc string
24880                         }))(obj)).Usable
24881                         switch n := read8(r); n {
24882                         case 0:
24883                                 *p = false
24884                         case 1:
24885                                 *p = true
24886                         default:
24887                                 chk(fmt.Errorf("invalid bool: %d", n))
24888                         }
24889                 }
24890                 {
24891                         p := &(*(*(struct {
24892                                 Type ItemType
24893
24894                                 Name, Desc string
24895
24896                                 InvImg, WieldImg Texture
24897                                 WieldScale       [3]float32
24898
24899                                 StackMax uint16
24900
24901                                 Usable          bool
24902                                 CanPointLiquids bool
24903
24904                                 ToolCaps ToolCaps
24905
24906                                 Groups []Group
24907
24908                                 PlacePredict string
24909
24910                                 PlaceSnd, PlaceFailSnd SoundDef
24911
24912                                 PointRange float32
24913
24914                                 // Set index in Palette with "palette_index" item meta field,
24915                                 // this overrides Color.
24916                                 Palette Texture
24917                                 Color   color.NRGBA
24918
24919                                 // Texture overlays.
24920                                 InvOverlay, WieldOverlay Texture
24921
24922                                 ShortDesc string
24923                         }))(obj)).CanPointLiquids
24924                         switch n := read8(r); n {
24925                         case 0:
24926                                 *p = false
24927                         case 1:
24928                                 *p = true
24929                         default:
24930                                 chk(fmt.Errorf("invalid bool: %d", n))
24931                         }
24932                 }
24933                 if err := pcall(func() {
24934                         ((*(*(struct {
24935                                 Type ItemType
24936
24937                                 Name, Desc string
24938
24939                                 InvImg, WieldImg Texture
24940                                 WieldScale       [3]float32
24941
24942                                 StackMax uint16
24943
24944                                 Usable          bool
24945                                 CanPointLiquids bool
24946
24947                                 ToolCaps ToolCaps
24948
24949                                 Groups []Group
24950
24951                                 PlacePredict string
24952
24953                                 PlaceSnd, PlaceFailSnd SoundDef
24954
24955                                 PointRange float32
24956
24957                                 // Set index in Palette with "palette_index" item meta field,
24958                                 // this overrides Color.
24959                                 Palette Texture
24960                                 Color   color.NRGBA
24961
24962                                 // Texture overlays.
24963                                 InvOverlay, WieldOverlay Texture
24964
24965                                 ShortDesc string
24966                         }))(obj)).ToolCaps).deserialize(r)
24967                 }); err != nil {
24968                         if err == io.EOF {
24969                                 chk(io.EOF)
24970                         }
24971                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolCaps", err))
24972                 }
24973                 var local307 uint16
24974                 {
24975                         p := &local307
24976                         *p = read16(r)
24977                 }
24978                 ((*(*(struct {
24979                         Type ItemType
24980
24981                         Name, Desc string
24982
24983                         InvImg, WieldImg Texture
24984                         WieldScale       [3]float32
24985
24986                         StackMax uint16
24987
24988                         Usable          bool
24989                         CanPointLiquids bool
24990
24991                         ToolCaps ToolCaps
24992
24993                         Groups []Group
24994
24995                         PlacePredict string
24996
24997                         PlaceSnd, PlaceFailSnd SoundDef
24998
24999                         PointRange float32
25000
25001                         // Set index in Palette with "palette_index" item meta field,
25002                         // this overrides Color.
25003                         Palette Texture
25004                         Color   color.NRGBA
25005
25006                         // Texture overlays.
25007                         InvOverlay, WieldOverlay Texture
25008
25009                         ShortDesc string
25010                 }))(obj)).Groups) = make([]Group, local307)
25011                 for local308 := range (*(*(struct {
25012                         Type ItemType
25013
25014                         Name, Desc string
25015
25016                         InvImg, WieldImg Texture
25017                         WieldScale       [3]float32
25018
25019                         StackMax uint16
25020
25021                         Usable          bool
25022                         CanPointLiquids bool
25023
25024                         ToolCaps ToolCaps
25025
25026                         Groups []Group
25027
25028                         PlacePredict string
25029
25030                         PlaceSnd, PlaceFailSnd SoundDef
25031
25032                         PointRange float32
25033
25034                         // Set index in Palette with "palette_index" item meta field,
25035                         // this overrides Color.
25036                         Palette Texture
25037                         Color   color.NRGBA
25038
25039                         // Texture overlays.
25040                         InvOverlay, WieldOverlay Texture
25041
25042                         ShortDesc string
25043                 }))(obj)).Groups {
25044                         if err := pcall(func() {
25045                                 (((*(*(struct {
25046                                         Type ItemType
25047
25048                                         Name, Desc string
25049
25050                                         InvImg, WieldImg Texture
25051                                         WieldScale       [3]float32
25052
25053                                         StackMax uint16
25054
25055                                         Usable          bool
25056                                         CanPointLiquids bool
25057
25058                                         ToolCaps ToolCaps
25059
25060                                         Groups []Group
25061
25062                                         PlacePredict string
25063
25064                                         PlaceSnd, PlaceFailSnd SoundDef
25065
25066                                         PointRange float32
25067
25068                                         // Set index in Palette with "palette_index" item meta field,
25069                                         // this overrides Color.
25070                                         Palette Texture
25071                                         Color   color.NRGBA
25072
25073                                         // Texture overlays.
25074                                         InvOverlay, WieldOverlay Texture
25075
25076                                         ShortDesc string
25077                                 }))(obj)).Groups)[local308]).deserialize(r)
25078                         }); err != nil {
25079                                 if err == io.EOF {
25080                                         chk(io.EOF)
25081                                 }
25082                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
25083                         }
25084                 }
25085                 var local309 []uint8
25086                 var local310 uint16
25087                 {
25088                         p := &local310
25089                         *p = read16(r)
25090                 }
25091                 (local309) = make([]uint8, local310)
25092                 {
25093                         _, err := io.ReadFull(r, (local309)[:])
25094                         chk(err)
25095                 }
25096                 ((*(*(struct {
25097                         Type ItemType
25098
25099                         Name, Desc string
25100
25101                         InvImg, WieldImg Texture
25102                         WieldScale       [3]float32
25103
25104                         StackMax uint16
25105
25106                         Usable          bool
25107                         CanPointLiquids bool
25108
25109                         ToolCaps ToolCaps
25110
25111                         Groups []Group
25112
25113                         PlacePredict string
25114
25115                         PlaceSnd, PlaceFailSnd SoundDef
25116
25117                         PointRange float32
25118
25119                         // Set index in Palette with "palette_index" item meta field,
25120                         // this overrides Color.
25121                         Palette Texture
25122                         Color   color.NRGBA
25123
25124                         // Texture overlays.
25125                         InvOverlay, WieldOverlay Texture
25126
25127                         ShortDesc string
25128                 }))(obj)).PlacePredict) = string(local309)
25129                 if err := pcall(func() {
25130                         ((*(*(struct {
25131                                 Type ItemType
25132
25133                                 Name, Desc string
25134
25135                                 InvImg, WieldImg Texture
25136                                 WieldScale       [3]float32
25137
25138                                 StackMax uint16
25139
25140                                 Usable          bool
25141                                 CanPointLiquids bool
25142
25143                                 ToolCaps ToolCaps
25144
25145                                 Groups []Group
25146
25147                                 PlacePredict string
25148
25149                                 PlaceSnd, PlaceFailSnd SoundDef
25150
25151                                 PointRange float32
25152
25153                                 // Set index in Palette with "palette_index" item meta field,
25154                                 // this overrides Color.
25155                                 Palette Texture
25156                                 Color   color.NRGBA
25157
25158                                 // Texture overlays.
25159                                 InvOverlay, WieldOverlay Texture
25160
25161                                 ShortDesc string
25162                         }))(obj)).PlaceSnd).deserialize(r)
25163                 }); err != nil {
25164                         if err == io.EOF {
25165                                 chk(io.EOF)
25166                         }
25167                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
25168                 }
25169                 if err := pcall(func() {
25170                         ((*(*(struct {
25171                                 Type ItemType
25172
25173                                 Name, Desc string
25174
25175                                 InvImg, WieldImg Texture
25176                                 WieldScale       [3]float32
25177
25178                                 StackMax uint16
25179
25180                                 Usable          bool
25181                                 CanPointLiquids bool
25182
25183                                 ToolCaps ToolCaps
25184
25185                                 Groups []Group
25186
25187                                 PlacePredict string
25188
25189                                 PlaceSnd, PlaceFailSnd SoundDef
25190
25191                                 PointRange float32
25192
25193                                 // Set index in Palette with "palette_index" item meta field,
25194                                 // this overrides Color.
25195                                 Palette Texture
25196                                 Color   color.NRGBA
25197
25198                                 // Texture overlays.
25199                                 InvOverlay, WieldOverlay Texture
25200
25201                                 ShortDesc string
25202                         }))(obj)).PlaceFailSnd).deserialize(r)
25203                 }); err != nil {
25204                         if err == io.EOF {
25205                                 chk(io.EOF)
25206                         }
25207                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
25208                 }
25209                 {
25210                         p := &(*(*(struct {
25211                                 Type ItemType
25212
25213                                 Name, Desc string
25214
25215                                 InvImg, WieldImg Texture
25216                                 WieldScale       [3]float32
25217
25218                                 StackMax uint16
25219
25220                                 Usable          bool
25221                                 CanPointLiquids bool
25222
25223                                 ToolCaps ToolCaps
25224
25225                                 Groups []Group
25226
25227                                 PlacePredict string
25228
25229                                 PlaceSnd, PlaceFailSnd SoundDef
25230
25231                                 PointRange float32
25232
25233                                 // Set index in Palette with "palette_index" item meta field,
25234                                 // this overrides Color.
25235                                 Palette Texture
25236                                 Color   color.NRGBA
25237
25238                                 // Texture overlays.
25239                                 InvOverlay, WieldOverlay Texture
25240
25241                                 ShortDesc string
25242                         }))(obj)).PointRange
25243                         *p = math.Float32frombits(read32(r))
25244                 }
25245                 if err := pcall(func() {
25246                         ((*(*(struct {
25247                                 Type ItemType
25248
25249                                 Name, Desc string
25250
25251                                 InvImg, WieldImg Texture
25252                                 WieldScale       [3]float32
25253
25254                                 StackMax uint16
25255
25256                                 Usable          bool
25257                                 CanPointLiquids bool
25258
25259                                 ToolCaps ToolCaps
25260
25261                                 Groups []Group
25262
25263                                 PlacePredict string
25264
25265                                 PlaceSnd, PlaceFailSnd SoundDef
25266
25267                                 PointRange float32
25268
25269                                 // Set index in Palette with "palette_index" item meta field,
25270                                 // this overrides Color.
25271                                 Palette Texture
25272                                 Color   color.NRGBA
25273
25274                                 // Texture overlays.
25275                                 InvOverlay, WieldOverlay Texture
25276
25277                                 ShortDesc string
25278                         }))(obj)).Palette).deserialize(r)
25279                 }); err != nil {
25280                         if err == io.EOF {
25281                                 chk(io.EOF)
25282                         }
25283                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
25284                 }
25285                 {
25286                         p := &(*(*(struct {
25287                                 Type ItemType
25288
25289                                 Name, Desc string
25290
25291                                 InvImg, WieldImg Texture
25292                                 WieldScale       [3]float32
25293
25294                                 StackMax uint16
25295
25296                                 Usable          bool
25297                                 CanPointLiquids bool
25298
25299                                 ToolCaps ToolCaps
25300
25301                                 Groups []Group
25302
25303                                 PlacePredict string
25304
25305                                 PlaceSnd, PlaceFailSnd SoundDef
25306
25307                                 PointRange float32
25308
25309                                 // Set index in Palette with "palette_index" item meta field,
25310                                 // this overrides Color.
25311                                 Palette Texture
25312                                 Color   color.NRGBA
25313
25314                                 // Texture overlays.
25315                                 InvOverlay, WieldOverlay Texture
25316
25317                                 ShortDesc string
25318                         }))(obj)).Color
25319                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25320                 }
25321                 if err := pcall(func() {
25322                         ((*(*(struct {
25323                                 Type ItemType
25324
25325                                 Name, Desc string
25326
25327                                 InvImg, WieldImg Texture
25328                                 WieldScale       [3]float32
25329
25330                                 StackMax uint16
25331
25332                                 Usable          bool
25333                                 CanPointLiquids bool
25334
25335                                 ToolCaps ToolCaps
25336
25337                                 Groups []Group
25338
25339                                 PlacePredict string
25340
25341                                 PlaceSnd, PlaceFailSnd SoundDef
25342
25343                                 PointRange float32
25344
25345                                 // Set index in Palette with "palette_index" item meta field,
25346                                 // this overrides Color.
25347                                 Palette Texture
25348                                 Color   color.NRGBA
25349
25350                                 // Texture overlays.
25351                                 InvOverlay, WieldOverlay Texture
25352
25353                                 ShortDesc string
25354                         }))(obj)).InvOverlay).deserialize(r)
25355                 }); err != nil {
25356                         if err == io.EOF {
25357                                 chk(io.EOF)
25358                         }
25359                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
25360                 }
25361                 if err := pcall(func() {
25362                         ((*(*(struct {
25363                                 Type ItemType
25364
25365                                 Name, Desc string
25366
25367                                 InvImg, WieldImg Texture
25368                                 WieldScale       [3]float32
25369
25370                                 StackMax uint16
25371
25372                                 Usable          bool
25373                                 CanPointLiquids bool
25374
25375                                 ToolCaps ToolCaps
25376
25377                                 Groups []Group
25378
25379                                 PlacePredict string
25380
25381                                 PlaceSnd, PlaceFailSnd SoundDef
25382
25383                                 PointRange float32
25384
25385                                 // Set index in Palette with "palette_index" item meta field,
25386                                 // this overrides Color.
25387                                 Palette Texture
25388                                 Color   color.NRGBA
25389
25390                                 // Texture overlays.
25391                                 InvOverlay, WieldOverlay Texture
25392
25393                                 ShortDesc string
25394                         }))(obj)).WieldOverlay).deserialize(r)
25395                 }); err != nil {
25396                         if err == io.EOF {
25397                                 chk(io.EOF)
25398                         }
25399                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
25400                 }
25401                 var local311 []uint8
25402                 var local312 uint16
25403                 {
25404                         p := &local312
25405                         *p = read16(r)
25406                 }
25407                 (local311) = make([]uint8, local312)
25408                 {
25409                         _, err := io.ReadFull(r, (local311)[:])
25410                         chk(err)
25411                 }
25412                 ((*(*(struct {
25413                         Type ItemType
25414
25415                         Name, Desc string
25416
25417                         InvImg, WieldImg Texture
25418                         WieldScale       [3]float32
25419
25420                         StackMax uint16
25421
25422                         Usable          bool
25423                         CanPointLiquids bool
25424
25425                         ToolCaps ToolCaps
25426
25427                         Groups []Group
25428
25429                         PlacePredict string
25430
25431                         PlaceSnd, PlaceFailSnd SoundDef
25432
25433                         PointRange float32
25434
25435                         // Set index in Palette with "palette_index" item meta field,
25436                         // this overrides Color.
25437                         Palette Texture
25438                         Color   color.NRGBA
25439
25440                         // Texture overlays.
25441                         InvOverlay, WieldOverlay Texture
25442
25443                         ShortDesc string
25444                 }))(obj)).ShortDesc) = string(local311)
25445                 if r.N > 0 {
25446                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25447                 }
25448         }
25449 }
25450
25451 func (obj *SoundSrcType) serialize(w io.Writer) {
25452         {
25453                 x := *(*(uint8))(obj)
25454                 write8(w, uint8(x))
25455         }
25456 }
25457
25458 func (obj *SoundSrcType) deserialize(r io.Reader) {
25459         {
25460                 p := &*(*(uint8))(obj)
25461                 *p = read8(r)
25462         }
25463 }
25464
25465 func (obj *TileAnim) serialize(w io.Writer) {
25466         if err := pcall(func() {
25467                 ((*(*(struct {
25468                         Type AnimType
25469
25470                         //mt:if %s.Type == SpriteSheetAnim
25471                         AspectRatio [2]uint8
25472
25473                         //mt:if %s.Type == VerticalFrameAnim
25474                         NFrames [2]uint16
25475
25476                         //mt:if %s.Type != NoAnim
25477                         Duration float32 // in seconds
25478
25479                 }))(obj)).Type).serialize(w)
25480         }); err != nil {
25481                 if err == io.EOF {
25482                         chk(io.EOF)
25483                 }
25484                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AnimType", err))
25485         }
25486         if !((*(*(struct {
25487                 Type AnimType
25488
25489                 //mt:if %s.Type == SpriteSheetAnim
25490                 AspectRatio [2]uint8
25491
25492                 //mt:if %s.Type == VerticalFrameAnim
25493                 NFrames [2]uint16
25494
25495                 //mt:if %s.Type != NoAnim
25496                 Duration float32 // in seconds
25497
25498         }))(obj)).Type < maxAnim) {
25499                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25500         }
25501         if (*(*(struct {
25502                 Type AnimType
25503
25504                 //mt:if %s.Type == SpriteSheetAnim
25505                 AspectRatio [2]uint8
25506
25507                 //mt:if %s.Type == VerticalFrameAnim
25508                 NFrames [2]uint16
25509
25510                 //mt:if %s.Type != NoAnim
25511                 Duration float32 // in seconds
25512
25513         }))(obj)).Type == SpriteSheetAnim {
25514                 {
25515                         _, err := w.Write(((*(*(struct {
25516                                 Type AnimType
25517
25518                                 //mt:if %s.Type == SpriteSheetAnim
25519                                 AspectRatio [2]uint8
25520
25521                                 //mt:if %s.Type == VerticalFrameAnim
25522                                 NFrames [2]uint16
25523
25524                                 //mt:if %s.Type != NoAnim
25525                                 Duration float32 // in seconds
25526
25527                         }))(obj)).AspectRatio)[:])
25528                         chk(err)
25529                 }
25530         }
25531         if (*(*(struct {
25532                 Type AnimType
25533
25534                 //mt:if %s.Type == SpriteSheetAnim
25535                 AspectRatio [2]uint8
25536
25537                 //mt:if %s.Type == VerticalFrameAnim
25538                 NFrames [2]uint16
25539
25540                 //mt:if %s.Type != NoAnim
25541                 Duration float32 // in seconds
25542
25543         }))(obj)).Type == VerticalFrameAnim {
25544                 for local313 := range (*(*(struct {
25545                         Type AnimType
25546
25547                         //mt:if %s.Type == SpriteSheetAnim
25548                         AspectRatio [2]uint8
25549
25550                         //mt:if %s.Type == VerticalFrameAnim
25551                         NFrames [2]uint16
25552
25553                         //mt:if %s.Type != NoAnim
25554                         Duration float32 // in seconds
25555
25556                 }))(obj)).NFrames {
25557                         {
25558                                 x := ((*(*(struct {
25559                                         Type AnimType
25560
25561                                         //mt:if %s.Type == SpriteSheetAnim
25562                                         AspectRatio [2]uint8
25563
25564                                         //mt:if %s.Type == VerticalFrameAnim
25565                                         NFrames [2]uint16
25566
25567                                         //mt:if %s.Type != NoAnim
25568                                         Duration float32 // in seconds
25569
25570                                 }))(obj)).NFrames)[local313]
25571                                 write16(w, uint16(x))
25572                         }
25573                 }
25574         }
25575         if (*(*(struct {
25576                 Type AnimType
25577
25578                 //mt:if %s.Type == SpriteSheetAnim
25579                 AspectRatio [2]uint8
25580
25581                 //mt:if %s.Type == VerticalFrameAnim
25582                 NFrames [2]uint16
25583
25584                 //mt:if %s.Type != NoAnim
25585                 Duration float32 // in seconds
25586
25587         }))(obj)).Type != NoAnim {
25588                 {
25589                         x := (*(*(struct {
25590                                 Type AnimType
25591
25592                                 //mt:if %s.Type == SpriteSheetAnim
25593                                 AspectRatio [2]uint8
25594
25595                                 //mt:if %s.Type == VerticalFrameAnim
25596                                 NFrames [2]uint16
25597
25598                                 //mt:if %s.Type != NoAnim
25599                                 Duration float32 // in seconds
25600
25601                         }))(obj)).Duration
25602                         write32(w, math.Float32bits(x))
25603                 }
25604         }
25605 }
25606
25607 func (obj *TileAnim) deserialize(r io.Reader) {
25608         if err := pcall(func() {
25609                 ((*(*(struct {
25610                         Type AnimType
25611
25612                         //mt:if %s.Type == SpriteSheetAnim
25613                         AspectRatio [2]uint8
25614
25615                         //mt:if %s.Type == VerticalFrameAnim
25616                         NFrames [2]uint16
25617
25618                         //mt:if %s.Type != NoAnim
25619                         Duration float32 // in seconds
25620
25621                 }))(obj)).Type).deserialize(r)
25622         }); err != nil {
25623                 if err == io.EOF {
25624                         chk(io.EOF)
25625                 }
25626                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AnimType", err))
25627         }
25628         if !((*(*(struct {
25629                 Type AnimType
25630
25631                 //mt:if %s.Type == SpriteSheetAnim
25632                 AspectRatio [2]uint8
25633
25634                 //mt:if %s.Type == VerticalFrameAnim
25635                 NFrames [2]uint16
25636
25637                 //mt:if %s.Type != NoAnim
25638                 Duration float32 // in seconds
25639
25640         }))(obj)).Type < maxAnim) {
25641                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25642         }
25643         if (*(*(struct {
25644                 Type AnimType
25645
25646                 //mt:if %s.Type == SpriteSheetAnim
25647                 AspectRatio [2]uint8
25648
25649                 //mt:if %s.Type == VerticalFrameAnim
25650                 NFrames [2]uint16
25651
25652                 //mt:if %s.Type != NoAnim
25653                 Duration float32 // in seconds
25654
25655         }))(obj)).Type == SpriteSheetAnim {
25656                 {
25657                         _, err := io.ReadFull(r, ((*(*(struct {
25658                                 Type AnimType
25659
25660                                 //mt:if %s.Type == SpriteSheetAnim
25661                                 AspectRatio [2]uint8
25662
25663                                 //mt:if %s.Type == VerticalFrameAnim
25664                                 NFrames [2]uint16
25665
25666                                 //mt:if %s.Type != NoAnim
25667                                 Duration float32 // in seconds
25668
25669                         }))(obj)).AspectRatio)[:])
25670                         chk(err)
25671                 }
25672         }
25673         if (*(*(struct {
25674                 Type AnimType
25675
25676                 //mt:if %s.Type == SpriteSheetAnim
25677                 AspectRatio [2]uint8
25678
25679                 //mt:if %s.Type == VerticalFrameAnim
25680                 NFrames [2]uint16
25681
25682                 //mt:if %s.Type != NoAnim
25683                 Duration float32 // in seconds
25684
25685         }))(obj)).Type == VerticalFrameAnim {
25686                 for local314 := range (*(*(struct {
25687                         Type AnimType
25688
25689                         //mt:if %s.Type == SpriteSheetAnim
25690                         AspectRatio [2]uint8
25691
25692                         //mt:if %s.Type == VerticalFrameAnim
25693                         NFrames [2]uint16
25694
25695                         //mt:if %s.Type != NoAnim
25696                         Duration float32 // in seconds
25697
25698                 }))(obj)).NFrames {
25699                         {
25700                                 p := &((*(*(struct {
25701                                         Type AnimType
25702
25703                                         //mt:if %s.Type == SpriteSheetAnim
25704                                         AspectRatio [2]uint8
25705
25706                                         //mt:if %s.Type == VerticalFrameAnim
25707                                         NFrames [2]uint16
25708
25709                                         //mt:if %s.Type != NoAnim
25710                                         Duration float32 // in seconds
25711
25712                                 }))(obj)).NFrames)[local314]
25713                                 *p = read16(r)
25714                         }
25715                 }
25716         }
25717         if (*(*(struct {
25718                 Type AnimType
25719
25720                 //mt:if %s.Type == SpriteSheetAnim
25721                 AspectRatio [2]uint8
25722
25723                 //mt:if %s.Type == VerticalFrameAnim
25724                 NFrames [2]uint16
25725
25726                 //mt:if %s.Type != NoAnim
25727                 Duration float32 // in seconds
25728
25729         }))(obj)).Type != NoAnim {
25730                 {
25731                         p := &(*(*(struct {
25732                                 Type AnimType
25733
25734                                 //mt:if %s.Type == SpriteSheetAnim
25735                                 AspectRatio [2]uint8
25736
25737                                 //mt:if %s.Type == VerticalFrameAnim
25738                                 NFrames [2]uint16
25739
25740                                 //mt:if %s.Type != NoAnim
25741                                 Duration float32 // in seconds
25742
25743                         }))(obj)).Duration
25744                         *p = math.Float32frombits(read32(r))
25745                 }
25746         }
25747 }
25748
25749 func (obj *Content) serialize(w io.Writer) {
25750         {
25751                 x := *(*(uint16))(obj)
25752                 write16(w, uint16(x))
25753         }
25754 }
25755
25756 func (obj *Content) deserialize(r io.Reader) {
25757         {
25758                 p := &*(*(uint16))(obj)
25759                 *p = read16(r)
25760         }
25761 }
25762
25763 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
25764         {
25765                 x := *(*(uint32))(obj)
25766                 write32(w, uint32(x))
25767         }
25768 }
25769
25770 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
25771         {
25772                 p := &*(*(uint32))(obj)
25773                 *p = read32(r)
25774         }
25775 }
25776
25777 func (obj *HUDID) serialize(w io.Writer) {
25778         {
25779                 x := *(*(uint32))(obj)
25780                 write32(w, uint32(x))
25781         }
25782 }
25783
25784 func (obj *HUDID) deserialize(r io.Reader) {
25785         {
25786                 p := &*(*(uint32))(obj)
25787                 *p = read32(r)
25788         }
25789 }
25790
25791 func (obj *HUD) serialize(w io.Writer) {
25792         if err := pcall(func() {
25793                 ((*(*(struct {
25794                         Type HUDType
25795
25796                         Pos      [2]float32
25797                         Name     string
25798                         Scale    [2]float32
25799                         Text     string
25800                         Number   uint32
25801                         Item     uint32
25802                         Dir      uint32
25803                         Align    [2]float32
25804                         Offset   [2]float32
25805                         WorldPos Pos
25806                         Size     [2]int32
25807                         ZIndex   int16
25808                         Text2    string
25809                 }))(obj)).Type).serialize(w)
25810         }); err != nil {
25811                 if err == io.EOF {
25812                         chk(io.EOF)
25813                 }
25814                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDType", err))
25815         }
25816         for local315 := range (*(*(struct {
25817                 Type HUDType
25818
25819                 Pos      [2]float32
25820                 Name     string
25821                 Scale    [2]float32
25822                 Text     string
25823                 Number   uint32
25824                 Item     uint32
25825                 Dir      uint32
25826                 Align    [2]float32
25827                 Offset   [2]float32
25828                 WorldPos Pos
25829                 Size     [2]int32
25830                 ZIndex   int16
25831                 Text2    string
25832         }))(obj)).Pos {
25833                 {
25834                         x := ((*(*(struct {
25835                                 Type HUDType
25836
25837                                 Pos      [2]float32
25838                                 Name     string
25839                                 Scale    [2]float32
25840                                 Text     string
25841                                 Number   uint32
25842                                 Item     uint32
25843                                 Dir      uint32
25844                                 Align    [2]float32
25845                                 Offset   [2]float32
25846                                 WorldPos Pos
25847                                 Size     [2]int32
25848                                 ZIndex   int16
25849                                 Text2    string
25850                         }))(obj)).Pos)[local315]
25851                         write32(w, math.Float32bits(x))
25852                 }
25853         }
25854         if len(([]byte((*(*(struct {
25855                 Type HUDType
25856
25857                 Pos      [2]float32
25858                 Name     string
25859                 Scale    [2]float32
25860                 Text     string
25861                 Number   uint32
25862                 Item     uint32
25863                 Dir      uint32
25864                 Align    [2]float32
25865                 Offset   [2]float32
25866                 WorldPos Pos
25867                 Size     [2]int32
25868                 ZIndex   int16
25869                 Text2    string
25870         }))(obj)).Name))) > math.MaxUint16 {
25871                 chk(ErrTooLong)
25872         }
25873         {
25874                 x := uint16(len(([]byte((*(*(struct {
25875                         Type HUDType
25876
25877                         Pos      [2]float32
25878                         Name     string
25879                         Scale    [2]float32
25880                         Text     string
25881                         Number   uint32
25882                         Item     uint32
25883                         Dir      uint32
25884                         Align    [2]float32
25885                         Offset   [2]float32
25886                         WorldPos Pos
25887                         Size     [2]int32
25888                         ZIndex   int16
25889                         Text2    string
25890                 }))(obj)).Name))))
25891                 write16(w, uint16(x))
25892         }
25893         {
25894                 _, err := w.Write(([]byte((*(*(struct {
25895                         Type HUDType
25896
25897                         Pos      [2]float32
25898                         Name     string
25899                         Scale    [2]float32
25900                         Text     string
25901                         Number   uint32
25902                         Item     uint32
25903                         Dir      uint32
25904                         Align    [2]float32
25905                         Offset   [2]float32
25906                         WorldPos Pos
25907                         Size     [2]int32
25908                         ZIndex   int16
25909                         Text2    string
25910                 }))(obj)).Name))[:])
25911                 chk(err)
25912         }
25913         for local316 := range (*(*(struct {
25914                 Type HUDType
25915
25916                 Pos      [2]float32
25917                 Name     string
25918                 Scale    [2]float32
25919                 Text     string
25920                 Number   uint32
25921                 Item     uint32
25922                 Dir      uint32
25923                 Align    [2]float32
25924                 Offset   [2]float32
25925                 WorldPos Pos
25926                 Size     [2]int32
25927                 ZIndex   int16
25928                 Text2    string
25929         }))(obj)).Scale {
25930                 {
25931                         x := ((*(*(struct {
25932                                 Type HUDType
25933
25934                                 Pos      [2]float32
25935                                 Name     string
25936                                 Scale    [2]float32
25937                                 Text     string
25938                                 Number   uint32
25939                                 Item     uint32
25940                                 Dir      uint32
25941                                 Align    [2]float32
25942                                 Offset   [2]float32
25943                                 WorldPos Pos
25944                                 Size     [2]int32
25945                                 ZIndex   int16
25946                                 Text2    string
25947                         }))(obj)).Scale)[local316]
25948                         write32(w, math.Float32bits(x))
25949                 }
25950         }
25951         if len(([]byte((*(*(struct {
25952                 Type HUDType
25953
25954                 Pos      [2]float32
25955                 Name     string
25956                 Scale    [2]float32
25957                 Text     string
25958                 Number   uint32
25959                 Item     uint32
25960                 Dir      uint32
25961                 Align    [2]float32
25962                 Offset   [2]float32
25963                 WorldPos Pos
25964                 Size     [2]int32
25965                 ZIndex   int16
25966                 Text2    string
25967         }))(obj)).Text))) > math.MaxUint16 {
25968                 chk(ErrTooLong)
25969         }
25970         {
25971                 x := uint16(len(([]byte((*(*(struct {
25972                         Type HUDType
25973
25974                         Pos      [2]float32
25975                         Name     string
25976                         Scale    [2]float32
25977                         Text     string
25978                         Number   uint32
25979                         Item     uint32
25980                         Dir      uint32
25981                         Align    [2]float32
25982                         Offset   [2]float32
25983                         WorldPos Pos
25984                         Size     [2]int32
25985                         ZIndex   int16
25986                         Text2    string
25987                 }))(obj)).Text))))
25988                 write16(w, uint16(x))
25989         }
25990         {
25991                 _, err := w.Write(([]byte((*(*(struct {
25992                         Type HUDType
25993
25994                         Pos      [2]float32
25995                         Name     string
25996                         Scale    [2]float32
25997                         Text     string
25998                         Number   uint32
25999                         Item     uint32
26000                         Dir      uint32
26001                         Align    [2]float32
26002                         Offset   [2]float32
26003                         WorldPos Pos
26004                         Size     [2]int32
26005                         ZIndex   int16
26006                         Text2    string
26007                 }))(obj)).Text))[:])
26008                 chk(err)
26009         }
26010         {
26011                 x := (*(*(struct {
26012                         Type HUDType
26013
26014                         Pos      [2]float32
26015                         Name     string
26016                         Scale    [2]float32
26017                         Text     string
26018                         Number   uint32
26019                         Item     uint32
26020                         Dir      uint32
26021                         Align    [2]float32
26022                         Offset   [2]float32
26023                         WorldPos Pos
26024                         Size     [2]int32
26025                         ZIndex   int16
26026                         Text2    string
26027                 }))(obj)).Number
26028                 write32(w, uint32(x))
26029         }
26030         {
26031                 x := (*(*(struct {
26032                         Type HUDType
26033
26034                         Pos      [2]float32
26035                         Name     string
26036                         Scale    [2]float32
26037                         Text     string
26038                         Number   uint32
26039                         Item     uint32
26040                         Dir      uint32
26041                         Align    [2]float32
26042                         Offset   [2]float32
26043                         WorldPos Pos
26044                         Size     [2]int32
26045                         ZIndex   int16
26046                         Text2    string
26047                 }))(obj)).Item
26048                 write32(w, uint32(x))
26049         }
26050         {
26051                 x := (*(*(struct {
26052                         Type HUDType
26053
26054                         Pos      [2]float32
26055                         Name     string
26056                         Scale    [2]float32
26057                         Text     string
26058                         Number   uint32
26059                         Item     uint32
26060                         Dir      uint32
26061                         Align    [2]float32
26062                         Offset   [2]float32
26063                         WorldPos Pos
26064                         Size     [2]int32
26065                         ZIndex   int16
26066                         Text2    string
26067                 }))(obj)).Dir
26068                 write32(w, uint32(x))
26069         }
26070         for local317 := range (*(*(struct {
26071                 Type HUDType
26072
26073                 Pos      [2]float32
26074                 Name     string
26075                 Scale    [2]float32
26076                 Text     string
26077                 Number   uint32
26078                 Item     uint32
26079                 Dir      uint32
26080                 Align    [2]float32
26081                 Offset   [2]float32
26082                 WorldPos Pos
26083                 Size     [2]int32
26084                 ZIndex   int16
26085                 Text2    string
26086         }))(obj)).Align {
26087                 {
26088                         x := ((*(*(struct {
26089                                 Type HUDType
26090
26091                                 Pos      [2]float32
26092                                 Name     string
26093                                 Scale    [2]float32
26094                                 Text     string
26095                                 Number   uint32
26096                                 Item     uint32
26097                                 Dir      uint32
26098                                 Align    [2]float32
26099                                 Offset   [2]float32
26100                                 WorldPos Pos
26101                                 Size     [2]int32
26102                                 ZIndex   int16
26103                                 Text2    string
26104                         }))(obj)).Align)[local317]
26105                         write32(w, math.Float32bits(x))
26106                 }
26107         }
26108         for local318 := range (*(*(struct {
26109                 Type HUDType
26110
26111                 Pos      [2]float32
26112                 Name     string
26113                 Scale    [2]float32
26114                 Text     string
26115                 Number   uint32
26116                 Item     uint32
26117                 Dir      uint32
26118                 Align    [2]float32
26119                 Offset   [2]float32
26120                 WorldPos Pos
26121                 Size     [2]int32
26122                 ZIndex   int16
26123                 Text2    string
26124         }))(obj)).Offset {
26125                 {
26126                         x := ((*(*(struct {
26127                                 Type HUDType
26128
26129                                 Pos      [2]float32
26130                                 Name     string
26131                                 Scale    [2]float32
26132                                 Text     string
26133                                 Number   uint32
26134                                 Item     uint32
26135                                 Dir      uint32
26136                                 Align    [2]float32
26137                                 Offset   [2]float32
26138                                 WorldPos Pos
26139                                 Size     [2]int32
26140                                 ZIndex   int16
26141                                 Text2    string
26142                         }))(obj)).Offset)[local318]
26143                         write32(w, math.Float32bits(x))
26144                 }
26145         }
26146         if err := pcall(func() {
26147                 ((*(*(struct {
26148                         Type HUDType
26149
26150                         Pos      [2]float32
26151                         Name     string
26152                         Scale    [2]float32
26153                         Text     string
26154                         Number   uint32
26155                         Item     uint32
26156                         Dir      uint32
26157                         Align    [2]float32
26158                         Offset   [2]float32
26159                         WorldPos Pos
26160                         Size     [2]int32
26161                         ZIndex   int16
26162                         Text2    string
26163                 }))(obj)).WorldPos).serialize(w)
26164         }); err != nil {
26165                 if err == io.EOF {
26166                         chk(io.EOF)
26167                 }
26168                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
26169         }
26170         for local319 := range (*(*(struct {
26171                 Type HUDType
26172
26173                 Pos      [2]float32
26174                 Name     string
26175                 Scale    [2]float32
26176                 Text     string
26177                 Number   uint32
26178                 Item     uint32
26179                 Dir      uint32
26180                 Align    [2]float32
26181                 Offset   [2]float32
26182                 WorldPos Pos
26183                 Size     [2]int32
26184                 ZIndex   int16
26185                 Text2    string
26186         }))(obj)).Size {
26187                 {
26188                         x := ((*(*(struct {
26189                                 Type HUDType
26190
26191                                 Pos      [2]float32
26192                                 Name     string
26193                                 Scale    [2]float32
26194                                 Text     string
26195                                 Number   uint32
26196                                 Item     uint32
26197                                 Dir      uint32
26198                                 Align    [2]float32
26199                                 Offset   [2]float32
26200                                 WorldPos Pos
26201                                 Size     [2]int32
26202                                 ZIndex   int16
26203                                 Text2    string
26204                         }))(obj)).Size)[local319]
26205                         write32(w, uint32(x))
26206                 }
26207         }
26208         {
26209                 x := (*(*(struct {
26210                         Type HUDType
26211
26212                         Pos      [2]float32
26213                         Name     string
26214                         Scale    [2]float32
26215                         Text     string
26216                         Number   uint32
26217                         Item     uint32
26218                         Dir      uint32
26219                         Align    [2]float32
26220                         Offset   [2]float32
26221                         WorldPos Pos
26222                         Size     [2]int32
26223                         ZIndex   int16
26224                         Text2    string
26225                 }))(obj)).ZIndex
26226                 write16(w, uint16(x))
26227         }
26228         if len(([]byte((*(*(struct {
26229                 Type HUDType
26230
26231                 Pos      [2]float32
26232                 Name     string
26233                 Scale    [2]float32
26234                 Text     string
26235                 Number   uint32
26236                 Item     uint32
26237                 Dir      uint32
26238                 Align    [2]float32
26239                 Offset   [2]float32
26240                 WorldPos Pos
26241                 Size     [2]int32
26242                 ZIndex   int16
26243                 Text2    string
26244         }))(obj)).Text2))) > math.MaxUint16 {
26245                 chk(ErrTooLong)
26246         }
26247         {
26248                 x := uint16(len(([]byte((*(*(struct {
26249                         Type HUDType
26250
26251                         Pos      [2]float32
26252                         Name     string
26253                         Scale    [2]float32
26254                         Text     string
26255                         Number   uint32
26256                         Item     uint32
26257                         Dir      uint32
26258                         Align    [2]float32
26259                         Offset   [2]float32
26260                         WorldPos Pos
26261                         Size     [2]int32
26262                         ZIndex   int16
26263                         Text2    string
26264                 }))(obj)).Text2))))
26265                 write16(w, uint16(x))
26266         }
26267         {
26268                 _, err := w.Write(([]byte((*(*(struct {
26269                         Type HUDType
26270
26271                         Pos      [2]float32
26272                         Name     string
26273                         Scale    [2]float32
26274                         Text     string
26275                         Number   uint32
26276                         Item     uint32
26277                         Dir      uint32
26278                         Align    [2]float32
26279                         Offset   [2]float32
26280                         WorldPos Pos
26281                         Size     [2]int32
26282                         ZIndex   int16
26283                         Text2    string
26284                 }))(obj)).Text2))[:])
26285                 chk(err)
26286         }
26287 }
26288
26289 func (obj *HUD) deserialize(r io.Reader) {
26290         if err := pcall(func() {
26291                 ((*(*(struct {
26292                         Type HUDType
26293
26294                         Pos      [2]float32
26295                         Name     string
26296                         Scale    [2]float32
26297                         Text     string
26298                         Number   uint32
26299                         Item     uint32
26300                         Dir      uint32
26301                         Align    [2]float32
26302                         Offset   [2]float32
26303                         WorldPos Pos
26304                         Size     [2]int32
26305                         ZIndex   int16
26306                         Text2    string
26307                 }))(obj)).Type).deserialize(r)
26308         }); err != nil {
26309                 if err == io.EOF {
26310                         chk(io.EOF)
26311                 }
26312                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDType", err))
26313         }
26314         for local320 := range (*(*(struct {
26315                 Type HUDType
26316
26317                 Pos      [2]float32
26318                 Name     string
26319                 Scale    [2]float32
26320                 Text     string
26321                 Number   uint32
26322                 Item     uint32
26323                 Dir      uint32
26324                 Align    [2]float32
26325                 Offset   [2]float32
26326                 WorldPos Pos
26327                 Size     [2]int32
26328                 ZIndex   int16
26329                 Text2    string
26330         }))(obj)).Pos {
26331                 {
26332                         p := &((*(*(struct {
26333                                 Type HUDType
26334
26335                                 Pos      [2]float32
26336                                 Name     string
26337                                 Scale    [2]float32
26338                                 Text     string
26339                                 Number   uint32
26340                                 Item     uint32
26341                                 Dir      uint32
26342                                 Align    [2]float32
26343                                 Offset   [2]float32
26344                                 WorldPos Pos
26345                                 Size     [2]int32
26346                                 ZIndex   int16
26347                                 Text2    string
26348                         }))(obj)).Pos)[local320]
26349                         *p = math.Float32frombits(read32(r))
26350                 }
26351         }
26352         var local321 []uint8
26353         var local322 uint16
26354         {
26355                 p := &local322
26356                 *p = read16(r)
26357         }
26358         (local321) = make([]uint8, local322)
26359         {
26360                 _, err := io.ReadFull(r, (local321)[:])
26361                 chk(err)
26362         }
26363         ((*(*(struct {
26364                 Type HUDType
26365
26366                 Pos      [2]float32
26367                 Name     string
26368                 Scale    [2]float32
26369                 Text     string
26370                 Number   uint32
26371                 Item     uint32
26372                 Dir      uint32
26373                 Align    [2]float32
26374                 Offset   [2]float32
26375                 WorldPos Pos
26376                 Size     [2]int32
26377                 ZIndex   int16
26378                 Text2    string
26379         }))(obj)).Name) = string(local321)
26380         for local323 := range (*(*(struct {
26381                 Type HUDType
26382
26383                 Pos      [2]float32
26384                 Name     string
26385                 Scale    [2]float32
26386                 Text     string
26387                 Number   uint32
26388                 Item     uint32
26389                 Dir      uint32
26390                 Align    [2]float32
26391                 Offset   [2]float32
26392                 WorldPos Pos
26393                 Size     [2]int32
26394                 ZIndex   int16
26395                 Text2    string
26396         }))(obj)).Scale {
26397                 {
26398                         p := &((*(*(struct {
26399                                 Type HUDType
26400
26401                                 Pos      [2]float32
26402                                 Name     string
26403                                 Scale    [2]float32
26404                                 Text     string
26405                                 Number   uint32
26406                                 Item     uint32
26407                                 Dir      uint32
26408                                 Align    [2]float32
26409                                 Offset   [2]float32
26410                                 WorldPos Pos
26411                                 Size     [2]int32
26412                                 ZIndex   int16
26413                                 Text2    string
26414                         }))(obj)).Scale)[local323]
26415                         *p = math.Float32frombits(read32(r))
26416                 }
26417         }
26418         var local324 []uint8
26419         var local325 uint16
26420         {
26421                 p := &local325
26422                 *p = read16(r)
26423         }
26424         (local324) = make([]uint8, local325)
26425         {
26426                 _, err := io.ReadFull(r, (local324)[:])
26427                 chk(err)
26428         }
26429         ((*(*(struct {
26430                 Type HUDType
26431
26432                 Pos      [2]float32
26433                 Name     string
26434                 Scale    [2]float32
26435                 Text     string
26436                 Number   uint32
26437                 Item     uint32
26438                 Dir      uint32
26439                 Align    [2]float32
26440                 Offset   [2]float32
26441                 WorldPos Pos
26442                 Size     [2]int32
26443                 ZIndex   int16
26444                 Text2    string
26445         }))(obj)).Text) = string(local324)
26446         {
26447                 p := &(*(*(struct {
26448                         Type HUDType
26449
26450                         Pos      [2]float32
26451                         Name     string
26452                         Scale    [2]float32
26453                         Text     string
26454                         Number   uint32
26455                         Item     uint32
26456                         Dir      uint32
26457                         Align    [2]float32
26458                         Offset   [2]float32
26459                         WorldPos Pos
26460                         Size     [2]int32
26461                         ZIndex   int16
26462                         Text2    string
26463                 }))(obj)).Number
26464                 *p = read32(r)
26465         }
26466         {
26467                 p := &(*(*(struct {
26468                         Type HUDType
26469
26470                         Pos      [2]float32
26471                         Name     string
26472                         Scale    [2]float32
26473                         Text     string
26474                         Number   uint32
26475                         Item     uint32
26476                         Dir      uint32
26477                         Align    [2]float32
26478                         Offset   [2]float32
26479                         WorldPos Pos
26480                         Size     [2]int32
26481                         ZIndex   int16
26482                         Text2    string
26483                 }))(obj)).Item
26484                 *p = read32(r)
26485         }
26486         {
26487                 p := &(*(*(struct {
26488                         Type HUDType
26489
26490                         Pos      [2]float32
26491                         Name     string
26492                         Scale    [2]float32
26493                         Text     string
26494                         Number   uint32
26495                         Item     uint32
26496                         Dir      uint32
26497                         Align    [2]float32
26498                         Offset   [2]float32
26499                         WorldPos Pos
26500                         Size     [2]int32
26501                         ZIndex   int16
26502                         Text2    string
26503                 }))(obj)).Dir
26504                 *p = read32(r)
26505         }
26506         for local326 := range (*(*(struct {
26507                 Type HUDType
26508
26509                 Pos      [2]float32
26510                 Name     string
26511                 Scale    [2]float32
26512                 Text     string
26513                 Number   uint32
26514                 Item     uint32
26515                 Dir      uint32
26516                 Align    [2]float32
26517                 Offset   [2]float32
26518                 WorldPos Pos
26519                 Size     [2]int32
26520                 ZIndex   int16
26521                 Text2    string
26522         }))(obj)).Align {
26523                 {
26524                         p := &((*(*(struct {
26525                                 Type HUDType
26526
26527                                 Pos      [2]float32
26528                                 Name     string
26529                                 Scale    [2]float32
26530                                 Text     string
26531                                 Number   uint32
26532                                 Item     uint32
26533                                 Dir      uint32
26534                                 Align    [2]float32
26535                                 Offset   [2]float32
26536                                 WorldPos Pos
26537                                 Size     [2]int32
26538                                 ZIndex   int16
26539                                 Text2    string
26540                         }))(obj)).Align)[local326]
26541                         *p = math.Float32frombits(read32(r))
26542                 }
26543         }
26544         for local327 := range (*(*(struct {
26545                 Type HUDType
26546
26547                 Pos      [2]float32
26548                 Name     string
26549                 Scale    [2]float32
26550                 Text     string
26551                 Number   uint32
26552                 Item     uint32
26553                 Dir      uint32
26554                 Align    [2]float32
26555                 Offset   [2]float32
26556                 WorldPos Pos
26557                 Size     [2]int32
26558                 ZIndex   int16
26559                 Text2    string
26560         }))(obj)).Offset {
26561                 {
26562                         p := &((*(*(struct {
26563                                 Type HUDType
26564
26565                                 Pos      [2]float32
26566                                 Name     string
26567                                 Scale    [2]float32
26568                                 Text     string
26569                                 Number   uint32
26570                                 Item     uint32
26571                                 Dir      uint32
26572                                 Align    [2]float32
26573                                 Offset   [2]float32
26574                                 WorldPos Pos
26575                                 Size     [2]int32
26576                                 ZIndex   int16
26577                                 Text2    string
26578                         }))(obj)).Offset)[local327]
26579                         *p = math.Float32frombits(read32(r))
26580                 }
26581         }
26582         if err := pcall(func() {
26583                 ((*(*(struct {
26584                         Type HUDType
26585
26586                         Pos      [2]float32
26587                         Name     string
26588                         Scale    [2]float32
26589                         Text     string
26590                         Number   uint32
26591                         Item     uint32
26592                         Dir      uint32
26593                         Align    [2]float32
26594                         Offset   [2]float32
26595                         WorldPos Pos
26596                         Size     [2]int32
26597                         ZIndex   int16
26598                         Text2    string
26599                 }))(obj)).WorldPos).deserialize(r)
26600         }); err != nil {
26601                 if err == io.EOF {
26602                         chk(io.EOF)
26603                 }
26604                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
26605         }
26606         for local328 := range (*(*(struct {
26607                 Type HUDType
26608
26609                 Pos      [2]float32
26610                 Name     string
26611                 Scale    [2]float32
26612                 Text     string
26613                 Number   uint32
26614                 Item     uint32
26615                 Dir      uint32
26616                 Align    [2]float32
26617                 Offset   [2]float32
26618                 WorldPos Pos
26619                 Size     [2]int32
26620                 ZIndex   int16
26621                 Text2    string
26622         }))(obj)).Size {
26623                 {
26624                         p := &((*(*(struct {
26625                                 Type HUDType
26626
26627                                 Pos      [2]float32
26628                                 Name     string
26629                                 Scale    [2]float32
26630                                 Text     string
26631                                 Number   uint32
26632                                 Item     uint32
26633                                 Dir      uint32
26634                                 Align    [2]float32
26635                                 Offset   [2]float32
26636                                 WorldPos Pos
26637                                 Size     [2]int32
26638                                 ZIndex   int16
26639                                 Text2    string
26640                         }))(obj)).Size)[local328]
26641                         *p = int32(read32(r))
26642                 }
26643         }
26644         {
26645                 p := &(*(*(struct {
26646                         Type HUDType
26647
26648                         Pos      [2]float32
26649                         Name     string
26650                         Scale    [2]float32
26651                         Text     string
26652                         Number   uint32
26653                         Item     uint32
26654                         Dir      uint32
26655                         Align    [2]float32
26656                         Offset   [2]float32
26657                         WorldPos Pos
26658                         Size     [2]int32
26659                         ZIndex   int16
26660                         Text2    string
26661                 }))(obj)).ZIndex
26662                 *p = int16(read16(r))
26663         }
26664         var local329 []uint8
26665         var local330 uint16
26666         {
26667                 p := &local330
26668                 *p = read16(r)
26669         }
26670         (local329) = make([]uint8, local330)
26671         {
26672                 _, err := io.ReadFull(r, (local329)[:])
26673                 chk(err)
26674         }
26675         ((*(*(struct {
26676                 Type HUDType
26677
26678                 Pos      [2]float32
26679                 Name     string
26680                 Scale    [2]float32
26681                 Text     string
26682                 Number   uint32
26683                 Item     uint32
26684                 Dir      uint32
26685                 Align    [2]float32
26686                 Offset   [2]float32
26687                 WorldPos Pos
26688                 Size     [2]int32
26689                 ZIndex   int16
26690                 Text2    string
26691         }))(obj)).Text2) = string(local329)
26692 }
26693
26694 func (obj *HUDField) serialize(w io.Writer) {
26695         {
26696                 x := *(*(uint8))(obj)
26697                 write8(w, uint8(x))
26698         }
26699 }
26700
26701 func (obj *HUDField) deserialize(r io.Reader) {
26702         {
26703                 p := &*(*(uint8))(obj)
26704                 *p = read8(r)
26705         }
26706 }
26707
26708 func (obj *HUDFlags) serialize(w io.Writer) {
26709         {
26710                 x := *(*(uint32))(obj)
26711                 write32(w, uint32(x))
26712         }
26713 }
26714
26715 func (obj *HUDFlags) deserialize(r io.Reader) {
26716         {
26717                 p := &*(*(uint32))(obj)
26718                 *p = read32(r)
26719         }
26720 }
26721
26722 func (obj *HotbarParam) serialize(w io.Writer) {
26723         {
26724                 x := *(*(uint16))(obj)
26725                 write16(w, uint16(x))
26726         }
26727 }
26728
26729 func (obj *HotbarParam) deserialize(r io.Reader) {
26730         {
26731                 p := &*(*(uint16))(obj)
26732                 *p = read16(r)
26733         }
26734 }
26735
26736 func (obj *Texture) serialize(w io.Writer) {
26737         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
26738                 chk(ErrTooLong)
26739         }
26740         {
26741                 x := uint16(len(([]byte(*(*(string))(obj)))))
26742                 write16(w, uint16(x))
26743         }
26744         {
26745                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
26746                 chk(err)
26747         }
26748 }
26749
26750 func (obj *Texture) deserialize(r io.Reader) {
26751         var local331 []uint8
26752         var local332 uint16
26753         {
26754                 p := &local332
26755                 *p = read16(r)
26756         }
26757         (local331) = make([]uint8, local332)
26758         {
26759                 _, err := io.ReadFull(r, (local331)[:])
26760                 chk(err)
26761         }
26762         (*(*(string))(obj)) = string(local331)
26763 }
26764
26765 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
26766         {
26767                 x := *(*(uint8))(obj)
26768                 write8(w, uint8(x))
26769         }
26770 }
26771
26772 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
26773         {
26774                 p := &*(*(uint8))(obj)
26775                 *p = read8(r)
26776         }
26777 }
26778
26779 func (obj *ModChanSig) serialize(w io.Writer) {
26780         {
26781                 x := *(*(uint8))(obj)
26782                 write8(w, uint8(x))
26783         }
26784 }
26785
26786 func (obj *ModChanSig) deserialize(r io.Reader) {
26787         {
26788                 p := &*(*(uint8))(obj)
26789                 *p = read8(r)
26790         }
26791 }
26792
26793 func (obj *AOProps) serialize(w io.Writer) {
26794         {
26795                 local333 := uint8(4)
26796                 {
26797                         x := local333
26798                         write8(w, uint8(x))
26799                 }
26800         }
26801         {
26802                 x := (*(*(struct {
26803                         MaxHP            uint16 // Player only.
26804                         CollideWithNodes bool
26805                         Weight           float32 // deprecated
26806                         ColBox, SelBox   Box
26807                         Pointable        bool
26808                         Visual           string
26809                         VisualSize       [3]float32
26810                         Textures         []Texture
26811                         SpriteSheetSize  [2]int16 // in sprites.
26812                         SpritePos        [2]int16 // in sprite sheet.
26813                         Visible          bool
26814                         MakeFootstepSnds bool
26815                         RotateSpeed      float32 // in radians per second.
26816                         Mesh             string
26817                         Colors           []color.NRGBA
26818                         CollideWithAOs   bool
26819                         StepHeight       float32
26820                         FaceRotateDir    bool
26821                         FaceRotateDirOff float32 // in degrees.
26822                         BackfaceCull     bool
26823                         Nametag          string
26824                         NametagColor     color.NRGBA
26825                         FaceRotateSpeed  float32 // in degrees per second.
26826                         Infotext         string
26827                         Itemstring       string
26828                         Glow             int8
26829                         MaxBreath        uint16  // Player only.
26830                         EyeHeight        float32 // Player only.
26831                         ZoomFOV          float32 // in degrees. Player only.
26832                         UseTextureAlpha  bool
26833                         DmgTextureMod    Texture // suffix
26834                         Shaded           bool
26835                         ShowOnMinimap    bool
26836                         NametagBG        color.NRGBA
26837                 }))(obj)).MaxHP
26838                 write16(w, uint16(x))
26839         }
26840         {
26841                 x := (*(*(struct {
26842                         MaxHP            uint16 // Player only.
26843                         CollideWithNodes bool
26844                         Weight           float32 // deprecated
26845                         ColBox, SelBox   Box
26846                         Pointable        bool
26847                         Visual           string
26848                         VisualSize       [3]float32
26849                         Textures         []Texture
26850                         SpriteSheetSize  [2]int16 // in sprites.
26851                         SpritePos        [2]int16 // in sprite sheet.
26852                         Visible          bool
26853                         MakeFootstepSnds bool
26854                         RotateSpeed      float32 // in radians per second.
26855                         Mesh             string
26856                         Colors           []color.NRGBA
26857                         CollideWithAOs   bool
26858                         StepHeight       float32
26859                         FaceRotateDir    bool
26860                         FaceRotateDirOff float32 // in degrees.
26861                         BackfaceCull     bool
26862                         Nametag          string
26863                         NametagColor     color.NRGBA
26864                         FaceRotateSpeed  float32 // in degrees per second.
26865                         Infotext         string
26866                         Itemstring       string
26867                         Glow             int8
26868                         MaxBreath        uint16  // Player only.
26869                         EyeHeight        float32 // Player only.
26870                         ZoomFOV          float32 // in degrees. Player only.
26871                         UseTextureAlpha  bool
26872                         DmgTextureMod    Texture // suffix
26873                         Shaded           bool
26874                         ShowOnMinimap    bool
26875                         NametagBG        color.NRGBA
26876                 }))(obj)).CollideWithNodes
26877                 if x {
26878                         write8(w, 1)
26879                 } else {
26880                         write8(w, 0)
26881                 }
26882         }
26883         {
26884                 x := (*(*(struct {
26885                         MaxHP            uint16 // Player only.
26886                         CollideWithNodes bool
26887                         Weight           float32 // deprecated
26888                         ColBox, SelBox   Box
26889                         Pointable        bool
26890                         Visual           string
26891                         VisualSize       [3]float32
26892                         Textures         []Texture
26893                         SpriteSheetSize  [2]int16 // in sprites.
26894                         SpritePos        [2]int16 // in sprite sheet.
26895                         Visible          bool
26896                         MakeFootstepSnds bool
26897                         RotateSpeed      float32 // in radians per second.
26898                         Mesh             string
26899                         Colors           []color.NRGBA
26900                         CollideWithAOs   bool
26901                         StepHeight       float32
26902                         FaceRotateDir    bool
26903                         FaceRotateDirOff float32 // in degrees.
26904                         BackfaceCull     bool
26905                         Nametag          string
26906                         NametagColor     color.NRGBA
26907                         FaceRotateSpeed  float32 // in degrees per second.
26908                         Infotext         string
26909                         Itemstring       string
26910                         Glow             int8
26911                         MaxBreath        uint16  // Player only.
26912                         EyeHeight        float32 // Player only.
26913                         ZoomFOV          float32 // in degrees. Player only.
26914                         UseTextureAlpha  bool
26915                         DmgTextureMod    Texture // suffix
26916                         Shaded           bool
26917                         ShowOnMinimap    bool
26918                         NametagBG        color.NRGBA
26919                 }))(obj)).Weight
26920                 write32(w, math.Float32bits(x))
26921         }
26922         if err := pcall(func() {
26923                 ((*(*(struct {
26924                         MaxHP            uint16 // Player only.
26925                         CollideWithNodes bool
26926                         Weight           float32 // deprecated
26927                         ColBox, SelBox   Box
26928                         Pointable        bool
26929                         Visual           string
26930                         VisualSize       [3]float32
26931                         Textures         []Texture
26932                         SpriteSheetSize  [2]int16 // in sprites.
26933                         SpritePos        [2]int16 // in sprite sheet.
26934                         Visible          bool
26935                         MakeFootstepSnds bool
26936                         RotateSpeed      float32 // in radians per second.
26937                         Mesh             string
26938                         Colors           []color.NRGBA
26939                         CollideWithAOs   bool
26940                         StepHeight       float32
26941                         FaceRotateDir    bool
26942                         FaceRotateDirOff float32 // in degrees.
26943                         BackfaceCull     bool
26944                         Nametag          string
26945                         NametagColor     color.NRGBA
26946                         FaceRotateSpeed  float32 // in degrees per second.
26947                         Infotext         string
26948                         Itemstring       string
26949                         Glow             int8
26950                         MaxBreath        uint16  // Player only.
26951                         EyeHeight        float32 // Player only.
26952                         ZoomFOV          float32 // in degrees. Player only.
26953                         UseTextureAlpha  bool
26954                         DmgTextureMod    Texture // suffix
26955                         Shaded           bool
26956                         ShowOnMinimap    bool
26957                         NametagBG        color.NRGBA
26958                 }))(obj)).ColBox).serialize(w)
26959         }); err != nil {
26960                 if err == io.EOF {
26961                         chk(io.EOF)
26962                 }
26963                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
26964         }
26965         if err := pcall(func() {
26966                 ((*(*(struct {
26967                         MaxHP            uint16 // Player only.
26968                         CollideWithNodes bool
26969                         Weight           float32 // deprecated
26970                         ColBox, SelBox   Box
26971                         Pointable        bool
26972                         Visual           string
26973                         VisualSize       [3]float32
26974                         Textures         []Texture
26975                         SpriteSheetSize  [2]int16 // in sprites.
26976                         SpritePos        [2]int16 // in sprite sheet.
26977                         Visible          bool
26978                         MakeFootstepSnds bool
26979                         RotateSpeed      float32 // in radians per second.
26980                         Mesh             string
26981                         Colors           []color.NRGBA
26982                         CollideWithAOs   bool
26983                         StepHeight       float32
26984                         FaceRotateDir    bool
26985                         FaceRotateDirOff float32 // in degrees.
26986                         BackfaceCull     bool
26987                         Nametag          string
26988                         NametagColor     color.NRGBA
26989                         FaceRotateSpeed  float32 // in degrees per second.
26990                         Infotext         string
26991                         Itemstring       string
26992                         Glow             int8
26993                         MaxBreath        uint16  // Player only.
26994                         EyeHeight        float32 // Player only.
26995                         ZoomFOV          float32 // in degrees. Player only.
26996                         UseTextureAlpha  bool
26997                         DmgTextureMod    Texture // suffix
26998                         Shaded           bool
26999                         ShowOnMinimap    bool
27000                         NametagBG        color.NRGBA
27001                 }))(obj)).SelBox).serialize(w)
27002         }); err != nil {
27003                 if err == io.EOF {
27004                         chk(io.EOF)
27005                 }
27006                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
27007         }
27008         {
27009                 x := (*(*(struct {
27010                         MaxHP            uint16 // Player only.
27011                         CollideWithNodes bool
27012                         Weight           float32 // deprecated
27013                         ColBox, SelBox   Box
27014                         Pointable        bool
27015                         Visual           string
27016                         VisualSize       [3]float32
27017                         Textures         []Texture
27018                         SpriteSheetSize  [2]int16 // in sprites.
27019                         SpritePos        [2]int16 // in sprite sheet.
27020                         Visible          bool
27021                         MakeFootstepSnds bool
27022                         RotateSpeed      float32 // in radians per second.
27023                         Mesh             string
27024                         Colors           []color.NRGBA
27025                         CollideWithAOs   bool
27026                         StepHeight       float32
27027                         FaceRotateDir    bool
27028                         FaceRotateDirOff float32 // in degrees.
27029                         BackfaceCull     bool
27030                         Nametag          string
27031                         NametagColor     color.NRGBA
27032                         FaceRotateSpeed  float32 // in degrees per second.
27033                         Infotext         string
27034                         Itemstring       string
27035                         Glow             int8
27036                         MaxBreath        uint16  // Player only.
27037                         EyeHeight        float32 // Player only.
27038                         ZoomFOV          float32 // in degrees. Player only.
27039                         UseTextureAlpha  bool
27040                         DmgTextureMod    Texture // suffix
27041                         Shaded           bool
27042                         ShowOnMinimap    bool
27043                         NametagBG        color.NRGBA
27044                 }))(obj)).Pointable
27045                 if x {
27046                         write8(w, 1)
27047                 } else {
27048                         write8(w, 0)
27049                 }
27050         }
27051         if len(([]byte((*(*(struct {
27052                 MaxHP            uint16 // Player only.
27053                 CollideWithNodes bool
27054                 Weight           float32 // deprecated
27055                 ColBox, SelBox   Box
27056                 Pointable        bool
27057                 Visual           string
27058                 VisualSize       [3]float32
27059                 Textures         []Texture
27060                 SpriteSheetSize  [2]int16 // in sprites.
27061                 SpritePos        [2]int16 // in sprite sheet.
27062                 Visible          bool
27063                 MakeFootstepSnds bool
27064                 RotateSpeed      float32 // in radians per second.
27065                 Mesh             string
27066                 Colors           []color.NRGBA
27067                 CollideWithAOs   bool
27068                 StepHeight       float32
27069                 FaceRotateDir    bool
27070                 FaceRotateDirOff float32 // in degrees.
27071                 BackfaceCull     bool
27072                 Nametag          string
27073                 NametagColor     color.NRGBA
27074                 FaceRotateSpeed  float32 // in degrees per second.
27075                 Infotext         string
27076                 Itemstring       string
27077                 Glow             int8
27078                 MaxBreath        uint16  // Player only.
27079                 EyeHeight        float32 // Player only.
27080                 ZoomFOV          float32 // in degrees. Player only.
27081                 UseTextureAlpha  bool
27082                 DmgTextureMod    Texture // suffix
27083                 Shaded           bool
27084                 ShowOnMinimap    bool
27085                 NametagBG        color.NRGBA
27086         }))(obj)).Visual))) > math.MaxUint16 {
27087                 chk(ErrTooLong)
27088         }
27089         {
27090                 x := uint16(len(([]byte((*(*(struct {
27091                         MaxHP            uint16 // Player only.
27092                         CollideWithNodes bool
27093                         Weight           float32 // deprecated
27094                         ColBox, SelBox   Box
27095                         Pointable        bool
27096                         Visual           string
27097                         VisualSize       [3]float32
27098                         Textures         []Texture
27099                         SpriteSheetSize  [2]int16 // in sprites.
27100                         SpritePos        [2]int16 // in sprite sheet.
27101                         Visible          bool
27102                         MakeFootstepSnds bool
27103                         RotateSpeed      float32 // in radians per second.
27104                         Mesh             string
27105                         Colors           []color.NRGBA
27106                         CollideWithAOs   bool
27107                         StepHeight       float32
27108                         FaceRotateDir    bool
27109                         FaceRotateDirOff float32 // in degrees.
27110                         BackfaceCull     bool
27111                         Nametag          string
27112                         NametagColor     color.NRGBA
27113                         FaceRotateSpeed  float32 // in degrees per second.
27114                         Infotext         string
27115                         Itemstring       string
27116                         Glow             int8
27117                         MaxBreath        uint16  // Player only.
27118                         EyeHeight        float32 // Player only.
27119                         ZoomFOV          float32 // in degrees. Player only.
27120                         UseTextureAlpha  bool
27121                         DmgTextureMod    Texture // suffix
27122                         Shaded           bool
27123                         ShowOnMinimap    bool
27124                         NametagBG        color.NRGBA
27125                 }))(obj)).Visual))))
27126                 write16(w, uint16(x))
27127         }
27128         {
27129                 _, err := w.Write(([]byte((*(*(struct {
27130                         MaxHP            uint16 // Player only.
27131                         CollideWithNodes bool
27132                         Weight           float32 // deprecated
27133                         ColBox, SelBox   Box
27134                         Pointable        bool
27135                         Visual           string
27136                         VisualSize       [3]float32
27137                         Textures         []Texture
27138                         SpriteSheetSize  [2]int16 // in sprites.
27139                         SpritePos        [2]int16 // in sprite sheet.
27140                         Visible          bool
27141                         MakeFootstepSnds bool
27142                         RotateSpeed      float32 // in radians per second.
27143                         Mesh             string
27144                         Colors           []color.NRGBA
27145                         CollideWithAOs   bool
27146                         StepHeight       float32
27147                         FaceRotateDir    bool
27148                         FaceRotateDirOff float32 // in degrees.
27149                         BackfaceCull     bool
27150                         Nametag          string
27151                         NametagColor     color.NRGBA
27152                         FaceRotateSpeed  float32 // in degrees per second.
27153                         Infotext         string
27154                         Itemstring       string
27155                         Glow             int8
27156                         MaxBreath        uint16  // Player only.
27157                         EyeHeight        float32 // Player only.
27158                         ZoomFOV          float32 // in degrees. Player only.
27159                         UseTextureAlpha  bool
27160                         DmgTextureMod    Texture // suffix
27161                         Shaded           bool
27162                         ShowOnMinimap    bool
27163                         NametagBG        color.NRGBA
27164                 }))(obj)).Visual))[:])
27165                 chk(err)
27166         }
27167         for local334 := range (*(*(struct {
27168                 MaxHP            uint16 // Player only.
27169                 CollideWithNodes bool
27170                 Weight           float32 // deprecated
27171                 ColBox, SelBox   Box
27172                 Pointable        bool
27173                 Visual           string
27174                 VisualSize       [3]float32
27175                 Textures         []Texture
27176                 SpriteSheetSize  [2]int16 // in sprites.
27177                 SpritePos        [2]int16 // in sprite sheet.
27178                 Visible          bool
27179                 MakeFootstepSnds bool
27180                 RotateSpeed      float32 // in radians per second.
27181                 Mesh             string
27182                 Colors           []color.NRGBA
27183                 CollideWithAOs   bool
27184                 StepHeight       float32
27185                 FaceRotateDir    bool
27186                 FaceRotateDirOff float32 // in degrees.
27187                 BackfaceCull     bool
27188                 Nametag          string
27189                 NametagColor     color.NRGBA
27190                 FaceRotateSpeed  float32 // in degrees per second.
27191                 Infotext         string
27192                 Itemstring       string
27193                 Glow             int8
27194                 MaxBreath        uint16  // Player only.
27195                 EyeHeight        float32 // Player only.
27196                 ZoomFOV          float32 // in degrees. Player only.
27197                 UseTextureAlpha  bool
27198                 DmgTextureMod    Texture // suffix
27199                 Shaded           bool
27200                 ShowOnMinimap    bool
27201                 NametagBG        color.NRGBA
27202         }))(obj)).VisualSize {
27203                 {
27204                         x := ((*(*(struct {
27205                                 MaxHP            uint16 // Player only.
27206                                 CollideWithNodes bool
27207                                 Weight           float32 // deprecated
27208                                 ColBox, SelBox   Box
27209                                 Pointable        bool
27210                                 Visual           string
27211                                 VisualSize       [3]float32
27212                                 Textures         []Texture
27213                                 SpriteSheetSize  [2]int16 // in sprites.
27214                                 SpritePos        [2]int16 // in sprite sheet.
27215                                 Visible          bool
27216                                 MakeFootstepSnds bool
27217                                 RotateSpeed      float32 // in radians per second.
27218                                 Mesh             string
27219                                 Colors           []color.NRGBA
27220                                 CollideWithAOs   bool
27221                                 StepHeight       float32
27222                                 FaceRotateDir    bool
27223                                 FaceRotateDirOff float32 // in degrees.
27224                                 BackfaceCull     bool
27225                                 Nametag          string
27226                                 NametagColor     color.NRGBA
27227                                 FaceRotateSpeed  float32 // in degrees per second.
27228                                 Infotext         string
27229                                 Itemstring       string
27230                                 Glow             int8
27231                                 MaxBreath        uint16  // Player only.
27232                                 EyeHeight        float32 // Player only.
27233                                 ZoomFOV          float32 // in degrees. Player only.
27234                                 UseTextureAlpha  bool
27235                                 DmgTextureMod    Texture // suffix
27236                                 Shaded           bool
27237                                 ShowOnMinimap    bool
27238                                 NametagBG        color.NRGBA
27239                         }))(obj)).VisualSize)[local334]
27240                         write32(w, math.Float32bits(x))
27241                 }
27242         }
27243         if len(((*(*(struct {
27244                 MaxHP            uint16 // Player only.
27245                 CollideWithNodes bool
27246                 Weight           float32 // deprecated
27247                 ColBox, SelBox   Box
27248                 Pointable        bool
27249                 Visual           string
27250                 VisualSize       [3]float32
27251                 Textures         []Texture
27252                 SpriteSheetSize  [2]int16 // in sprites.
27253                 SpritePos        [2]int16 // in sprite sheet.
27254                 Visible          bool
27255                 MakeFootstepSnds bool
27256                 RotateSpeed      float32 // in radians per second.
27257                 Mesh             string
27258                 Colors           []color.NRGBA
27259                 CollideWithAOs   bool
27260                 StepHeight       float32
27261                 FaceRotateDir    bool
27262                 FaceRotateDirOff float32 // in degrees.
27263                 BackfaceCull     bool
27264                 Nametag          string
27265                 NametagColor     color.NRGBA
27266                 FaceRotateSpeed  float32 // in degrees per second.
27267                 Infotext         string
27268                 Itemstring       string
27269                 Glow             int8
27270                 MaxBreath        uint16  // Player only.
27271                 EyeHeight        float32 // Player only.
27272                 ZoomFOV          float32 // in degrees. Player only.
27273                 UseTextureAlpha  bool
27274                 DmgTextureMod    Texture // suffix
27275                 Shaded           bool
27276                 ShowOnMinimap    bool
27277                 NametagBG        color.NRGBA
27278         }))(obj)).Textures)) > math.MaxUint16 {
27279                 chk(ErrTooLong)
27280         }
27281         {
27282                 x := uint16(len(((*(*(struct {
27283                         MaxHP            uint16 // Player only.
27284                         CollideWithNodes bool
27285                         Weight           float32 // deprecated
27286                         ColBox, SelBox   Box
27287                         Pointable        bool
27288                         Visual           string
27289                         VisualSize       [3]float32
27290                         Textures         []Texture
27291                         SpriteSheetSize  [2]int16 // in sprites.
27292                         SpritePos        [2]int16 // in sprite sheet.
27293                         Visible          bool
27294                         MakeFootstepSnds bool
27295                         RotateSpeed      float32 // in radians per second.
27296                         Mesh             string
27297                         Colors           []color.NRGBA
27298                         CollideWithAOs   bool
27299                         StepHeight       float32
27300                         FaceRotateDir    bool
27301                         FaceRotateDirOff float32 // in degrees.
27302                         BackfaceCull     bool
27303                         Nametag          string
27304                         NametagColor     color.NRGBA
27305                         FaceRotateSpeed  float32 // in degrees per second.
27306                         Infotext         string
27307                         Itemstring       string
27308                         Glow             int8
27309                         MaxBreath        uint16  // Player only.
27310                         EyeHeight        float32 // Player only.
27311                         ZoomFOV          float32 // in degrees. Player only.
27312                         UseTextureAlpha  bool
27313                         DmgTextureMod    Texture // suffix
27314                         Shaded           bool
27315                         ShowOnMinimap    bool
27316                         NametagBG        color.NRGBA
27317                 }))(obj)).Textures)))
27318                 write16(w, uint16(x))
27319         }
27320         for local335 := range (*(*(struct {
27321                 MaxHP            uint16 // Player only.
27322                 CollideWithNodes bool
27323                 Weight           float32 // deprecated
27324                 ColBox, SelBox   Box
27325                 Pointable        bool
27326                 Visual           string
27327                 VisualSize       [3]float32
27328                 Textures         []Texture
27329                 SpriteSheetSize  [2]int16 // in sprites.
27330                 SpritePos        [2]int16 // in sprite sheet.
27331                 Visible          bool
27332                 MakeFootstepSnds bool
27333                 RotateSpeed      float32 // in radians per second.
27334                 Mesh             string
27335                 Colors           []color.NRGBA
27336                 CollideWithAOs   bool
27337                 StepHeight       float32
27338                 FaceRotateDir    bool
27339                 FaceRotateDirOff float32 // in degrees.
27340                 BackfaceCull     bool
27341                 Nametag          string
27342                 NametagColor     color.NRGBA
27343                 FaceRotateSpeed  float32 // in degrees per second.
27344                 Infotext         string
27345                 Itemstring       string
27346                 Glow             int8
27347                 MaxBreath        uint16  // Player only.
27348                 EyeHeight        float32 // Player only.
27349                 ZoomFOV          float32 // in degrees. Player only.
27350                 UseTextureAlpha  bool
27351                 DmgTextureMod    Texture // suffix
27352                 Shaded           bool
27353                 ShowOnMinimap    bool
27354                 NametagBG        color.NRGBA
27355         }))(obj)).Textures {
27356                 if err := pcall(func() {
27357                         (((*(*(struct {
27358                                 MaxHP            uint16 // Player only.
27359                                 CollideWithNodes bool
27360                                 Weight           float32 // deprecated
27361                                 ColBox, SelBox   Box
27362                                 Pointable        bool
27363                                 Visual           string
27364                                 VisualSize       [3]float32
27365                                 Textures         []Texture
27366                                 SpriteSheetSize  [2]int16 // in sprites.
27367                                 SpritePos        [2]int16 // in sprite sheet.
27368                                 Visible          bool
27369                                 MakeFootstepSnds bool
27370                                 RotateSpeed      float32 // in radians per second.
27371                                 Mesh             string
27372                                 Colors           []color.NRGBA
27373                                 CollideWithAOs   bool
27374                                 StepHeight       float32
27375                                 FaceRotateDir    bool
27376                                 FaceRotateDirOff float32 // in degrees.
27377                                 BackfaceCull     bool
27378                                 Nametag          string
27379                                 NametagColor     color.NRGBA
27380                                 FaceRotateSpeed  float32 // in degrees per second.
27381                                 Infotext         string
27382                                 Itemstring       string
27383                                 Glow             int8
27384                                 MaxBreath        uint16  // Player only.
27385                                 EyeHeight        float32 // Player only.
27386                                 ZoomFOV          float32 // in degrees. Player only.
27387                                 UseTextureAlpha  bool
27388                                 DmgTextureMod    Texture // suffix
27389                                 Shaded           bool
27390                                 ShowOnMinimap    bool
27391                                 NametagBG        color.NRGBA
27392                         }))(obj)).Textures)[local335]).serialize(w)
27393                 }); err != nil {
27394                         if err == io.EOF {
27395                                 chk(io.EOF)
27396                         }
27397                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
27398                 }
27399         }
27400         for local336 := range (*(*(struct {
27401                 MaxHP            uint16 // Player only.
27402                 CollideWithNodes bool
27403                 Weight           float32 // deprecated
27404                 ColBox, SelBox   Box
27405                 Pointable        bool
27406                 Visual           string
27407                 VisualSize       [3]float32
27408                 Textures         []Texture
27409                 SpriteSheetSize  [2]int16 // in sprites.
27410                 SpritePos        [2]int16 // in sprite sheet.
27411                 Visible          bool
27412                 MakeFootstepSnds bool
27413                 RotateSpeed      float32 // in radians per second.
27414                 Mesh             string
27415                 Colors           []color.NRGBA
27416                 CollideWithAOs   bool
27417                 StepHeight       float32
27418                 FaceRotateDir    bool
27419                 FaceRotateDirOff float32 // in degrees.
27420                 BackfaceCull     bool
27421                 Nametag          string
27422                 NametagColor     color.NRGBA
27423                 FaceRotateSpeed  float32 // in degrees per second.
27424                 Infotext         string
27425                 Itemstring       string
27426                 Glow             int8
27427                 MaxBreath        uint16  // Player only.
27428                 EyeHeight        float32 // Player only.
27429                 ZoomFOV          float32 // in degrees. Player only.
27430                 UseTextureAlpha  bool
27431                 DmgTextureMod    Texture // suffix
27432                 Shaded           bool
27433                 ShowOnMinimap    bool
27434                 NametagBG        color.NRGBA
27435         }))(obj)).SpriteSheetSize {
27436                 {
27437                         x := ((*(*(struct {
27438                                 MaxHP            uint16 // Player only.
27439                                 CollideWithNodes bool
27440                                 Weight           float32 // deprecated
27441                                 ColBox, SelBox   Box
27442                                 Pointable        bool
27443                                 Visual           string
27444                                 VisualSize       [3]float32
27445                                 Textures         []Texture
27446                                 SpriteSheetSize  [2]int16 // in sprites.
27447                                 SpritePos        [2]int16 // in sprite sheet.
27448                                 Visible          bool
27449                                 MakeFootstepSnds bool
27450                                 RotateSpeed      float32 // in radians per second.
27451                                 Mesh             string
27452                                 Colors           []color.NRGBA
27453                                 CollideWithAOs   bool
27454                                 StepHeight       float32
27455                                 FaceRotateDir    bool
27456                                 FaceRotateDirOff float32 // in degrees.
27457                                 BackfaceCull     bool
27458                                 Nametag          string
27459                                 NametagColor     color.NRGBA
27460                                 FaceRotateSpeed  float32 // in degrees per second.
27461                                 Infotext         string
27462                                 Itemstring       string
27463                                 Glow             int8
27464                                 MaxBreath        uint16  // Player only.
27465                                 EyeHeight        float32 // Player only.
27466                                 ZoomFOV          float32 // in degrees. Player only.
27467                                 UseTextureAlpha  bool
27468                                 DmgTextureMod    Texture // suffix
27469                                 Shaded           bool
27470                                 ShowOnMinimap    bool
27471                                 NametagBG        color.NRGBA
27472                         }))(obj)).SpriteSheetSize)[local336]
27473                         write16(w, uint16(x))
27474                 }
27475         }
27476         for local337 := range (*(*(struct {
27477                 MaxHP            uint16 // Player only.
27478                 CollideWithNodes bool
27479                 Weight           float32 // deprecated
27480                 ColBox, SelBox   Box
27481                 Pointable        bool
27482                 Visual           string
27483                 VisualSize       [3]float32
27484                 Textures         []Texture
27485                 SpriteSheetSize  [2]int16 // in sprites.
27486                 SpritePos        [2]int16 // in sprite sheet.
27487                 Visible          bool
27488                 MakeFootstepSnds bool
27489                 RotateSpeed      float32 // in radians per second.
27490                 Mesh             string
27491                 Colors           []color.NRGBA
27492                 CollideWithAOs   bool
27493                 StepHeight       float32
27494                 FaceRotateDir    bool
27495                 FaceRotateDirOff float32 // in degrees.
27496                 BackfaceCull     bool
27497                 Nametag          string
27498                 NametagColor     color.NRGBA
27499                 FaceRotateSpeed  float32 // in degrees per second.
27500                 Infotext         string
27501                 Itemstring       string
27502                 Glow             int8
27503                 MaxBreath        uint16  // Player only.
27504                 EyeHeight        float32 // Player only.
27505                 ZoomFOV          float32 // in degrees. Player only.
27506                 UseTextureAlpha  bool
27507                 DmgTextureMod    Texture // suffix
27508                 Shaded           bool
27509                 ShowOnMinimap    bool
27510                 NametagBG        color.NRGBA
27511         }))(obj)).SpritePos {
27512                 {
27513                         x := ((*(*(struct {
27514                                 MaxHP            uint16 // Player only.
27515                                 CollideWithNodes bool
27516                                 Weight           float32 // deprecated
27517                                 ColBox, SelBox   Box
27518                                 Pointable        bool
27519                                 Visual           string
27520                                 VisualSize       [3]float32
27521                                 Textures         []Texture
27522                                 SpriteSheetSize  [2]int16 // in sprites.
27523                                 SpritePos        [2]int16 // in sprite sheet.
27524                                 Visible          bool
27525                                 MakeFootstepSnds bool
27526                                 RotateSpeed      float32 // in radians per second.
27527                                 Mesh             string
27528                                 Colors           []color.NRGBA
27529                                 CollideWithAOs   bool
27530                                 StepHeight       float32
27531                                 FaceRotateDir    bool
27532                                 FaceRotateDirOff float32 // in degrees.
27533                                 BackfaceCull     bool
27534                                 Nametag          string
27535                                 NametagColor     color.NRGBA
27536                                 FaceRotateSpeed  float32 // in degrees per second.
27537                                 Infotext         string
27538                                 Itemstring       string
27539                                 Glow             int8
27540                                 MaxBreath        uint16  // Player only.
27541                                 EyeHeight        float32 // Player only.
27542                                 ZoomFOV          float32 // in degrees. Player only.
27543                                 UseTextureAlpha  bool
27544                                 DmgTextureMod    Texture // suffix
27545                                 Shaded           bool
27546                                 ShowOnMinimap    bool
27547                                 NametagBG        color.NRGBA
27548                         }))(obj)).SpritePos)[local337]
27549                         write16(w, uint16(x))
27550                 }
27551         }
27552         {
27553                 x := (*(*(struct {
27554                         MaxHP            uint16 // Player only.
27555                         CollideWithNodes bool
27556                         Weight           float32 // deprecated
27557                         ColBox, SelBox   Box
27558                         Pointable        bool
27559                         Visual           string
27560                         VisualSize       [3]float32
27561                         Textures         []Texture
27562                         SpriteSheetSize  [2]int16 // in sprites.
27563                         SpritePos        [2]int16 // in sprite sheet.
27564                         Visible          bool
27565                         MakeFootstepSnds bool
27566                         RotateSpeed      float32 // in radians per second.
27567                         Mesh             string
27568                         Colors           []color.NRGBA
27569                         CollideWithAOs   bool
27570                         StepHeight       float32
27571                         FaceRotateDir    bool
27572                         FaceRotateDirOff float32 // in degrees.
27573                         BackfaceCull     bool
27574                         Nametag          string
27575                         NametagColor     color.NRGBA
27576                         FaceRotateSpeed  float32 // in degrees per second.
27577                         Infotext         string
27578                         Itemstring       string
27579                         Glow             int8
27580                         MaxBreath        uint16  // Player only.
27581                         EyeHeight        float32 // Player only.
27582                         ZoomFOV          float32 // in degrees. Player only.
27583                         UseTextureAlpha  bool
27584                         DmgTextureMod    Texture // suffix
27585                         Shaded           bool
27586                         ShowOnMinimap    bool
27587                         NametagBG        color.NRGBA
27588                 }))(obj)).Visible
27589                 if x {
27590                         write8(w, 1)
27591                 } else {
27592                         write8(w, 0)
27593                 }
27594         }
27595         {
27596                 x := (*(*(struct {
27597                         MaxHP            uint16 // Player only.
27598                         CollideWithNodes bool
27599                         Weight           float32 // deprecated
27600                         ColBox, SelBox   Box
27601                         Pointable        bool
27602                         Visual           string
27603                         VisualSize       [3]float32
27604                         Textures         []Texture
27605                         SpriteSheetSize  [2]int16 // in sprites.
27606                         SpritePos        [2]int16 // in sprite sheet.
27607                         Visible          bool
27608                         MakeFootstepSnds bool
27609                         RotateSpeed      float32 // in radians per second.
27610                         Mesh             string
27611                         Colors           []color.NRGBA
27612                         CollideWithAOs   bool
27613                         StepHeight       float32
27614                         FaceRotateDir    bool
27615                         FaceRotateDirOff float32 // in degrees.
27616                         BackfaceCull     bool
27617                         Nametag          string
27618                         NametagColor     color.NRGBA
27619                         FaceRotateSpeed  float32 // in degrees per second.
27620                         Infotext         string
27621                         Itemstring       string
27622                         Glow             int8
27623                         MaxBreath        uint16  // Player only.
27624                         EyeHeight        float32 // Player only.
27625                         ZoomFOV          float32 // in degrees. Player only.
27626                         UseTextureAlpha  bool
27627                         DmgTextureMod    Texture // suffix
27628                         Shaded           bool
27629                         ShowOnMinimap    bool
27630                         NametagBG        color.NRGBA
27631                 }))(obj)).MakeFootstepSnds
27632                 if x {
27633                         write8(w, 1)
27634                 } else {
27635                         write8(w, 0)
27636                 }
27637         }
27638         {
27639                 x := (*(*(struct {
27640                         MaxHP            uint16 // Player only.
27641                         CollideWithNodes bool
27642                         Weight           float32 // deprecated
27643                         ColBox, SelBox   Box
27644                         Pointable        bool
27645                         Visual           string
27646                         VisualSize       [3]float32
27647                         Textures         []Texture
27648                         SpriteSheetSize  [2]int16 // in sprites.
27649                         SpritePos        [2]int16 // in sprite sheet.
27650                         Visible          bool
27651                         MakeFootstepSnds bool
27652                         RotateSpeed      float32 // in radians per second.
27653                         Mesh             string
27654                         Colors           []color.NRGBA
27655                         CollideWithAOs   bool
27656                         StepHeight       float32
27657                         FaceRotateDir    bool
27658                         FaceRotateDirOff float32 // in degrees.
27659                         BackfaceCull     bool
27660                         Nametag          string
27661                         NametagColor     color.NRGBA
27662                         FaceRotateSpeed  float32 // in degrees per second.
27663                         Infotext         string
27664                         Itemstring       string
27665                         Glow             int8
27666                         MaxBreath        uint16  // Player only.
27667                         EyeHeight        float32 // Player only.
27668                         ZoomFOV          float32 // in degrees. Player only.
27669                         UseTextureAlpha  bool
27670                         DmgTextureMod    Texture // suffix
27671                         Shaded           bool
27672                         ShowOnMinimap    bool
27673                         NametagBG        color.NRGBA
27674                 }))(obj)).RotateSpeed
27675                 write32(w, math.Float32bits(x))
27676         }
27677         if len(([]byte((*(*(struct {
27678                 MaxHP            uint16 // Player only.
27679                 CollideWithNodes bool
27680                 Weight           float32 // deprecated
27681                 ColBox, SelBox   Box
27682                 Pointable        bool
27683                 Visual           string
27684                 VisualSize       [3]float32
27685                 Textures         []Texture
27686                 SpriteSheetSize  [2]int16 // in sprites.
27687                 SpritePos        [2]int16 // in sprite sheet.
27688                 Visible          bool
27689                 MakeFootstepSnds bool
27690                 RotateSpeed      float32 // in radians per second.
27691                 Mesh             string
27692                 Colors           []color.NRGBA
27693                 CollideWithAOs   bool
27694                 StepHeight       float32
27695                 FaceRotateDir    bool
27696                 FaceRotateDirOff float32 // in degrees.
27697                 BackfaceCull     bool
27698                 Nametag          string
27699                 NametagColor     color.NRGBA
27700                 FaceRotateSpeed  float32 // in degrees per second.
27701                 Infotext         string
27702                 Itemstring       string
27703                 Glow             int8
27704                 MaxBreath        uint16  // Player only.
27705                 EyeHeight        float32 // Player only.
27706                 ZoomFOV          float32 // in degrees. Player only.
27707                 UseTextureAlpha  bool
27708                 DmgTextureMod    Texture // suffix
27709                 Shaded           bool
27710                 ShowOnMinimap    bool
27711                 NametagBG        color.NRGBA
27712         }))(obj)).Mesh))) > math.MaxUint16 {
27713                 chk(ErrTooLong)
27714         }
27715         {
27716                 x := uint16(len(([]byte((*(*(struct {
27717                         MaxHP            uint16 // Player only.
27718                         CollideWithNodes bool
27719                         Weight           float32 // deprecated
27720                         ColBox, SelBox   Box
27721                         Pointable        bool
27722                         Visual           string
27723                         VisualSize       [3]float32
27724                         Textures         []Texture
27725                         SpriteSheetSize  [2]int16 // in sprites.
27726                         SpritePos        [2]int16 // in sprite sheet.
27727                         Visible          bool
27728                         MakeFootstepSnds bool
27729                         RotateSpeed      float32 // in radians per second.
27730                         Mesh             string
27731                         Colors           []color.NRGBA
27732                         CollideWithAOs   bool
27733                         StepHeight       float32
27734                         FaceRotateDir    bool
27735                         FaceRotateDirOff float32 // in degrees.
27736                         BackfaceCull     bool
27737                         Nametag          string
27738                         NametagColor     color.NRGBA
27739                         FaceRotateSpeed  float32 // in degrees per second.
27740                         Infotext         string
27741                         Itemstring       string
27742                         Glow             int8
27743                         MaxBreath        uint16  // Player only.
27744                         EyeHeight        float32 // Player only.
27745                         ZoomFOV          float32 // in degrees. Player only.
27746                         UseTextureAlpha  bool
27747                         DmgTextureMod    Texture // suffix
27748                         Shaded           bool
27749                         ShowOnMinimap    bool
27750                         NametagBG        color.NRGBA
27751                 }))(obj)).Mesh))))
27752                 write16(w, uint16(x))
27753         }
27754         {
27755                 _, err := w.Write(([]byte((*(*(struct {
27756                         MaxHP            uint16 // Player only.
27757                         CollideWithNodes bool
27758                         Weight           float32 // deprecated
27759                         ColBox, SelBox   Box
27760                         Pointable        bool
27761                         Visual           string
27762                         VisualSize       [3]float32
27763                         Textures         []Texture
27764                         SpriteSheetSize  [2]int16 // in sprites.
27765                         SpritePos        [2]int16 // in sprite sheet.
27766                         Visible          bool
27767                         MakeFootstepSnds bool
27768                         RotateSpeed      float32 // in radians per second.
27769                         Mesh             string
27770                         Colors           []color.NRGBA
27771                         CollideWithAOs   bool
27772                         StepHeight       float32
27773                         FaceRotateDir    bool
27774                         FaceRotateDirOff float32 // in degrees.
27775                         BackfaceCull     bool
27776                         Nametag          string
27777                         NametagColor     color.NRGBA
27778                         FaceRotateSpeed  float32 // in degrees per second.
27779                         Infotext         string
27780                         Itemstring       string
27781                         Glow             int8
27782                         MaxBreath        uint16  // Player only.
27783                         EyeHeight        float32 // Player only.
27784                         ZoomFOV          float32 // in degrees. Player only.
27785                         UseTextureAlpha  bool
27786                         DmgTextureMod    Texture // suffix
27787                         Shaded           bool
27788                         ShowOnMinimap    bool
27789                         NametagBG        color.NRGBA
27790                 }))(obj)).Mesh))[:])
27791                 chk(err)
27792         }
27793         if len(((*(*(struct {
27794                 MaxHP            uint16 // Player only.
27795                 CollideWithNodes bool
27796                 Weight           float32 // deprecated
27797                 ColBox, SelBox   Box
27798                 Pointable        bool
27799                 Visual           string
27800                 VisualSize       [3]float32
27801                 Textures         []Texture
27802                 SpriteSheetSize  [2]int16 // in sprites.
27803                 SpritePos        [2]int16 // in sprite sheet.
27804                 Visible          bool
27805                 MakeFootstepSnds bool
27806                 RotateSpeed      float32 // in radians per second.
27807                 Mesh             string
27808                 Colors           []color.NRGBA
27809                 CollideWithAOs   bool
27810                 StepHeight       float32
27811                 FaceRotateDir    bool
27812                 FaceRotateDirOff float32 // in degrees.
27813                 BackfaceCull     bool
27814                 Nametag          string
27815                 NametagColor     color.NRGBA
27816                 FaceRotateSpeed  float32 // in degrees per second.
27817                 Infotext         string
27818                 Itemstring       string
27819                 Glow             int8
27820                 MaxBreath        uint16  // Player only.
27821                 EyeHeight        float32 // Player only.
27822                 ZoomFOV          float32 // in degrees. Player only.
27823                 UseTextureAlpha  bool
27824                 DmgTextureMod    Texture // suffix
27825                 Shaded           bool
27826                 ShowOnMinimap    bool
27827                 NametagBG        color.NRGBA
27828         }))(obj)).Colors)) > math.MaxUint16 {
27829                 chk(ErrTooLong)
27830         }
27831         {
27832                 x := uint16(len(((*(*(struct {
27833                         MaxHP            uint16 // Player only.
27834                         CollideWithNodes bool
27835                         Weight           float32 // deprecated
27836                         ColBox, SelBox   Box
27837                         Pointable        bool
27838                         Visual           string
27839                         VisualSize       [3]float32
27840                         Textures         []Texture
27841                         SpriteSheetSize  [2]int16 // in sprites.
27842                         SpritePos        [2]int16 // in sprite sheet.
27843                         Visible          bool
27844                         MakeFootstepSnds bool
27845                         RotateSpeed      float32 // in radians per second.
27846                         Mesh             string
27847                         Colors           []color.NRGBA
27848                         CollideWithAOs   bool
27849                         StepHeight       float32
27850                         FaceRotateDir    bool
27851                         FaceRotateDirOff float32 // in degrees.
27852                         BackfaceCull     bool
27853                         Nametag          string
27854                         NametagColor     color.NRGBA
27855                         FaceRotateSpeed  float32 // in degrees per second.
27856                         Infotext         string
27857                         Itemstring       string
27858                         Glow             int8
27859                         MaxBreath        uint16  // Player only.
27860                         EyeHeight        float32 // Player only.
27861                         ZoomFOV          float32 // in degrees. Player only.
27862                         UseTextureAlpha  bool
27863                         DmgTextureMod    Texture // suffix
27864                         Shaded           bool
27865                         ShowOnMinimap    bool
27866                         NametagBG        color.NRGBA
27867                 }))(obj)).Colors)))
27868                 write16(w, uint16(x))
27869         }
27870         for local338 := range (*(*(struct {
27871                 MaxHP            uint16 // Player only.
27872                 CollideWithNodes bool
27873                 Weight           float32 // deprecated
27874                 ColBox, SelBox   Box
27875                 Pointable        bool
27876                 Visual           string
27877                 VisualSize       [3]float32
27878                 Textures         []Texture
27879                 SpriteSheetSize  [2]int16 // in sprites.
27880                 SpritePos        [2]int16 // in sprite sheet.
27881                 Visible          bool
27882                 MakeFootstepSnds bool
27883                 RotateSpeed      float32 // in radians per second.
27884                 Mesh             string
27885                 Colors           []color.NRGBA
27886                 CollideWithAOs   bool
27887                 StepHeight       float32
27888                 FaceRotateDir    bool
27889                 FaceRotateDirOff float32 // in degrees.
27890                 BackfaceCull     bool
27891                 Nametag          string
27892                 NametagColor     color.NRGBA
27893                 FaceRotateSpeed  float32 // in degrees per second.
27894                 Infotext         string
27895                 Itemstring       string
27896                 Glow             int8
27897                 MaxBreath        uint16  // Player only.
27898                 EyeHeight        float32 // Player only.
27899                 ZoomFOV          float32 // in degrees. Player only.
27900                 UseTextureAlpha  bool
27901                 DmgTextureMod    Texture // suffix
27902                 Shaded           bool
27903                 ShowOnMinimap    bool
27904                 NametagBG        color.NRGBA
27905         }))(obj)).Colors {
27906                 {
27907                         x := ((*(*(struct {
27908                                 MaxHP            uint16 // Player only.
27909                                 CollideWithNodes bool
27910                                 Weight           float32 // deprecated
27911                                 ColBox, SelBox   Box
27912                                 Pointable        bool
27913                                 Visual           string
27914                                 VisualSize       [3]float32
27915                                 Textures         []Texture
27916                                 SpriteSheetSize  [2]int16 // in sprites.
27917                                 SpritePos        [2]int16 // in sprite sheet.
27918                                 Visible          bool
27919                                 MakeFootstepSnds bool
27920                                 RotateSpeed      float32 // in radians per second.
27921                                 Mesh             string
27922                                 Colors           []color.NRGBA
27923                                 CollideWithAOs   bool
27924                                 StepHeight       float32
27925                                 FaceRotateDir    bool
27926                                 FaceRotateDirOff float32 // in degrees.
27927                                 BackfaceCull     bool
27928                                 Nametag          string
27929                                 NametagColor     color.NRGBA
27930                                 FaceRotateSpeed  float32 // in degrees per second.
27931                                 Infotext         string
27932                                 Itemstring       string
27933                                 Glow             int8
27934                                 MaxBreath        uint16  // Player only.
27935                                 EyeHeight        float32 // Player only.
27936                                 ZoomFOV          float32 // in degrees. Player only.
27937                                 UseTextureAlpha  bool
27938                                 DmgTextureMod    Texture // suffix
27939                                 Shaded           bool
27940                                 ShowOnMinimap    bool
27941                                 NametagBG        color.NRGBA
27942                         }))(obj)).Colors)[local338]
27943                         w.Write([]byte{x.A, x.R, x.G, x.B})
27944                 }
27945         }
27946         {
27947                 x := (*(*(struct {
27948                         MaxHP            uint16 // Player only.
27949                         CollideWithNodes bool
27950                         Weight           float32 // deprecated
27951                         ColBox, SelBox   Box
27952                         Pointable        bool
27953                         Visual           string
27954                         VisualSize       [3]float32
27955                         Textures         []Texture
27956                         SpriteSheetSize  [2]int16 // in sprites.
27957                         SpritePos        [2]int16 // in sprite sheet.
27958                         Visible          bool
27959                         MakeFootstepSnds bool
27960                         RotateSpeed      float32 // in radians per second.
27961                         Mesh             string
27962                         Colors           []color.NRGBA
27963                         CollideWithAOs   bool
27964                         StepHeight       float32
27965                         FaceRotateDir    bool
27966                         FaceRotateDirOff float32 // in degrees.
27967                         BackfaceCull     bool
27968                         Nametag          string
27969                         NametagColor     color.NRGBA
27970                         FaceRotateSpeed  float32 // in degrees per second.
27971                         Infotext         string
27972                         Itemstring       string
27973                         Glow             int8
27974                         MaxBreath        uint16  // Player only.
27975                         EyeHeight        float32 // Player only.
27976                         ZoomFOV          float32 // in degrees. Player only.
27977                         UseTextureAlpha  bool
27978                         DmgTextureMod    Texture // suffix
27979                         Shaded           bool
27980                         ShowOnMinimap    bool
27981                         NametagBG        color.NRGBA
27982                 }))(obj)).CollideWithAOs
27983                 if x {
27984                         write8(w, 1)
27985                 } else {
27986                         write8(w, 0)
27987                 }
27988         }
27989         {
27990                 x := (*(*(struct {
27991                         MaxHP            uint16 // Player only.
27992                         CollideWithNodes bool
27993                         Weight           float32 // deprecated
27994                         ColBox, SelBox   Box
27995                         Pointable        bool
27996                         Visual           string
27997                         VisualSize       [3]float32
27998                         Textures         []Texture
27999                         SpriteSheetSize  [2]int16 // in sprites.
28000                         SpritePos        [2]int16 // in sprite sheet.
28001                         Visible          bool
28002                         MakeFootstepSnds bool
28003                         RotateSpeed      float32 // in radians per second.
28004                         Mesh             string
28005                         Colors           []color.NRGBA
28006                         CollideWithAOs   bool
28007                         StepHeight       float32
28008                         FaceRotateDir    bool
28009                         FaceRotateDirOff float32 // in degrees.
28010                         BackfaceCull     bool
28011                         Nametag          string
28012                         NametagColor     color.NRGBA
28013                         FaceRotateSpeed  float32 // in degrees per second.
28014                         Infotext         string
28015                         Itemstring       string
28016                         Glow             int8
28017                         MaxBreath        uint16  // Player only.
28018                         EyeHeight        float32 // Player only.
28019                         ZoomFOV          float32 // in degrees. Player only.
28020                         UseTextureAlpha  bool
28021                         DmgTextureMod    Texture // suffix
28022                         Shaded           bool
28023                         ShowOnMinimap    bool
28024                         NametagBG        color.NRGBA
28025                 }))(obj)).StepHeight
28026                 write32(w, math.Float32bits(x))
28027         }
28028         {
28029                 x := (*(*(struct {
28030                         MaxHP            uint16 // Player only.
28031                         CollideWithNodes bool
28032                         Weight           float32 // deprecated
28033                         ColBox, SelBox   Box
28034                         Pointable        bool
28035                         Visual           string
28036                         VisualSize       [3]float32
28037                         Textures         []Texture
28038                         SpriteSheetSize  [2]int16 // in sprites.
28039                         SpritePos        [2]int16 // in sprite sheet.
28040                         Visible          bool
28041                         MakeFootstepSnds bool
28042                         RotateSpeed      float32 // in radians per second.
28043                         Mesh             string
28044                         Colors           []color.NRGBA
28045                         CollideWithAOs   bool
28046                         StepHeight       float32
28047                         FaceRotateDir    bool
28048                         FaceRotateDirOff float32 // in degrees.
28049                         BackfaceCull     bool
28050                         Nametag          string
28051                         NametagColor     color.NRGBA
28052                         FaceRotateSpeed  float32 // in degrees per second.
28053                         Infotext         string
28054                         Itemstring       string
28055                         Glow             int8
28056                         MaxBreath        uint16  // Player only.
28057                         EyeHeight        float32 // Player only.
28058                         ZoomFOV          float32 // in degrees. Player only.
28059                         UseTextureAlpha  bool
28060                         DmgTextureMod    Texture // suffix
28061                         Shaded           bool
28062                         ShowOnMinimap    bool
28063                         NametagBG        color.NRGBA
28064                 }))(obj)).FaceRotateDir
28065                 if x {
28066                         write8(w, 1)
28067                 } else {
28068                         write8(w, 0)
28069                 }
28070         }
28071         {
28072                 x := (*(*(struct {
28073                         MaxHP            uint16 // Player only.
28074                         CollideWithNodes bool
28075                         Weight           float32 // deprecated
28076                         ColBox, SelBox   Box
28077                         Pointable        bool
28078                         Visual           string
28079                         VisualSize       [3]float32
28080                         Textures         []Texture
28081                         SpriteSheetSize  [2]int16 // in sprites.
28082                         SpritePos        [2]int16 // in sprite sheet.
28083                         Visible          bool
28084                         MakeFootstepSnds bool
28085                         RotateSpeed      float32 // in radians per second.
28086                         Mesh             string
28087                         Colors           []color.NRGBA
28088                         CollideWithAOs   bool
28089                         StepHeight       float32
28090                         FaceRotateDir    bool
28091                         FaceRotateDirOff float32 // in degrees.
28092                         BackfaceCull     bool
28093                         Nametag          string
28094                         NametagColor     color.NRGBA
28095                         FaceRotateSpeed  float32 // in degrees per second.
28096                         Infotext         string
28097                         Itemstring       string
28098                         Glow             int8
28099                         MaxBreath        uint16  // Player only.
28100                         EyeHeight        float32 // Player only.
28101                         ZoomFOV          float32 // in degrees. Player only.
28102                         UseTextureAlpha  bool
28103                         DmgTextureMod    Texture // suffix
28104                         Shaded           bool
28105                         ShowOnMinimap    bool
28106                         NametagBG        color.NRGBA
28107                 }))(obj)).FaceRotateDirOff
28108                 write32(w, math.Float32bits(x))
28109         }
28110         {
28111                 x := (*(*(struct {
28112                         MaxHP            uint16 // Player only.
28113                         CollideWithNodes bool
28114                         Weight           float32 // deprecated
28115                         ColBox, SelBox   Box
28116                         Pointable        bool
28117                         Visual           string
28118                         VisualSize       [3]float32
28119                         Textures         []Texture
28120                         SpriteSheetSize  [2]int16 // in sprites.
28121                         SpritePos        [2]int16 // in sprite sheet.
28122                         Visible          bool
28123                         MakeFootstepSnds bool
28124                         RotateSpeed      float32 // in radians per second.
28125                         Mesh             string
28126                         Colors           []color.NRGBA
28127                         CollideWithAOs   bool
28128                         StepHeight       float32
28129                         FaceRotateDir    bool
28130                         FaceRotateDirOff float32 // in degrees.
28131                         BackfaceCull     bool
28132                         Nametag          string
28133                         NametagColor     color.NRGBA
28134                         FaceRotateSpeed  float32 // in degrees per second.
28135                         Infotext         string
28136                         Itemstring       string
28137                         Glow             int8
28138                         MaxBreath        uint16  // Player only.
28139                         EyeHeight        float32 // Player only.
28140                         ZoomFOV          float32 // in degrees. Player only.
28141                         UseTextureAlpha  bool
28142                         DmgTextureMod    Texture // suffix
28143                         Shaded           bool
28144                         ShowOnMinimap    bool
28145                         NametagBG        color.NRGBA
28146                 }))(obj)).BackfaceCull
28147                 if x {
28148                         write8(w, 1)
28149                 } else {
28150                         write8(w, 0)
28151                 }
28152         }
28153         if len(([]byte((*(*(struct {
28154                 MaxHP            uint16 // Player only.
28155                 CollideWithNodes bool
28156                 Weight           float32 // deprecated
28157                 ColBox, SelBox   Box
28158                 Pointable        bool
28159                 Visual           string
28160                 VisualSize       [3]float32
28161                 Textures         []Texture
28162                 SpriteSheetSize  [2]int16 // in sprites.
28163                 SpritePos        [2]int16 // in sprite sheet.
28164                 Visible          bool
28165                 MakeFootstepSnds bool
28166                 RotateSpeed      float32 // in radians per second.
28167                 Mesh             string
28168                 Colors           []color.NRGBA
28169                 CollideWithAOs   bool
28170                 StepHeight       float32
28171                 FaceRotateDir    bool
28172                 FaceRotateDirOff float32 // in degrees.
28173                 BackfaceCull     bool
28174                 Nametag          string
28175                 NametagColor     color.NRGBA
28176                 FaceRotateSpeed  float32 // in degrees per second.
28177                 Infotext         string
28178                 Itemstring       string
28179                 Glow             int8
28180                 MaxBreath        uint16  // Player only.
28181                 EyeHeight        float32 // Player only.
28182                 ZoomFOV          float32 // in degrees. Player only.
28183                 UseTextureAlpha  bool
28184                 DmgTextureMod    Texture // suffix
28185                 Shaded           bool
28186                 ShowOnMinimap    bool
28187                 NametagBG        color.NRGBA
28188         }))(obj)).Nametag))) > math.MaxUint16 {
28189                 chk(ErrTooLong)
28190         }
28191         {
28192                 x := uint16(len(([]byte((*(*(struct {
28193                         MaxHP            uint16 // Player only.
28194                         CollideWithNodes bool
28195                         Weight           float32 // deprecated
28196                         ColBox, SelBox   Box
28197                         Pointable        bool
28198                         Visual           string
28199                         VisualSize       [3]float32
28200                         Textures         []Texture
28201                         SpriteSheetSize  [2]int16 // in sprites.
28202                         SpritePos        [2]int16 // in sprite sheet.
28203                         Visible          bool
28204                         MakeFootstepSnds bool
28205                         RotateSpeed      float32 // in radians per second.
28206                         Mesh             string
28207                         Colors           []color.NRGBA
28208                         CollideWithAOs   bool
28209                         StepHeight       float32
28210                         FaceRotateDir    bool
28211                         FaceRotateDirOff float32 // in degrees.
28212                         BackfaceCull     bool
28213                         Nametag          string
28214                         NametagColor     color.NRGBA
28215                         FaceRotateSpeed  float32 // in degrees per second.
28216                         Infotext         string
28217                         Itemstring       string
28218                         Glow             int8
28219                         MaxBreath        uint16  // Player only.
28220                         EyeHeight        float32 // Player only.
28221                         ZoomFOV          float32 // in degrees. Player only.
28222                         UseTextureAlpha  bool
28223                         DmgTextureMod    Texture // suffix
28224                         Shaded           bool
28225                         ShowOnMinimap    bool
28226                         NametagBG        color.NRGBA
28227                 }))(obj)).Nametag))))
28228                 write16(w, uint16(x))
28229         }
28230         {
28231                 _, err := w.Write(([]byte((*(*(struct {
28232                         MaxHP            uint16 // Player only.
28233                         CollideWithNodes bool
28234                         Weight           float32 // deprecated
28235                         ColBox, SelBox   Box
28236                         Pointable        bool
28237                         Visual           string
28238                         VisualSize       [3]float32
28239                         Textures         []Texture
28240                         SpriteSheetSize  [2]int16 // in sprites.
28241                         SpritePos        [2]int16 // in sprite sheet.
28242                         Visible          bool
28243                         MakeFootstepSnds bool
28244                         RotateSpeed      float32 // in radians per second.
28245                         Mesh             string
28246                         Colors           []color.NRGBA
28247                         CollideWithAOs   bool
28248                         StepHeight       float32
28249                         FaceRotateDir    bool
28250                         FaceRotateDirOff float32 // in degrees.
28251                         BackfaceCull     bool
28252                         Nametag          string
28253                         NametagColor     color.NRGBA
28254                         FaceRotateSpeed  float32 // in degrees per second.
28255                         Infotext         string
28256                         Itemstring       string
28257                         Glow             int8
28258                         MaxBreath        uint16  // Player only.
28259                         EyeHeight        float32 // Player only.
28260                         ZoomFOV          float32 // in degrees. Player only.
28261                         UseTextureAlpha  bool
28262                         DmgTextureMod    Texture // suffix
28263                         Shaded           bool
28264                         ShowOnMinimap    bool
28265                         NametagBG        color.NRGBA
28266                 }))(obj)).Nametag))[:])
28267                 chk(err)
28268         }
28269         {
28270                 x := (*(*(struct {
28271                         MaxHP            uint16 // Player only.
28272                         CollideWithNodes bool
28273                         Weight           float32 // deprecated
28274                         ColBox, SelBox   Box
28275                         Pointable        bool
28276                         Visual           string
28277                         VisualSize       [3]float32
28278                         Textures         []Texture
28279                         SpriteSheetSize  [2]int16 // in sprites.
28280                         SpritePos        [2]int16 // in sprite sheet.
28281                         Visible          bool
28282                         MakeFootstepSnds bool
28283                         RotateSpeed      float32 // in radians per second.
28284                         Mesh             string
28285                         Colors           []color.NRGBA
28286                         CollideWithAOs   bool
28287                         StepHeight       float32
28288                         FaceRotateDir    bool
28289                         FaceRotateDirOff float32 // in degrees.
28290                         BackfaceCull     bool
28291                         Nametag          string
28292                         NametagColor     color.NRGBA
28293                         FaceRotateSpeed  float32 // in degrees per second.
28294                         Infotext         string
28295                         Itemstring       string
28296                         Glow             int8
28297                         MaxBreath        uint16  // Player only.
28298                         EyeHeight        float32 // Player only.
28299                         ZoomFOV          float32 // in degrees. Player only.
28300                         UseTextureAlpha  bool
28301                         DmgTextureMod    Texture // suffix
28302                         Shaded           bool
28303                         ShowOnMinimap    bool
28304                         NametagBG        color.NRGBA
28305                 }))(obj)).NametagColor
28306                 w.Write([]byte{x.A, x.R, x.G, x.B})
28307         }
28308         {
28309                 x := (*(*(struct {
28310                         MaxHP            uint16 // Player only.
28311                         CollideWithNodes bool
28312                         Weight           float32 // deprecated
28313                         ColBox, SelBox   Box
28314                         Pointable        bool
28315                         Visual           string
28316                         VisualSize       [3]float32
28317                         Textures         []Texture
28318                         SpriteSheetSize  [2]int16 // in sprites.
28319                         SpritePos        [2]int16 // in sprite sheet.
28320                         Visible          bool
28321                         MakeFootstepSnds bool
28322                         RotateSpeed      float32 // in radians per second.
28323                         Mesh             string
28324                         Colors           []color.NRGBA
28325                         CollideWithAOs   bool
28326                         StepHeight       float32
28327                         FaceRotateDir    bool
28328                         FaceRotateDirOff float32 // in degrees.
28329                         BackfaceCull     bool
28330                         Nametag          string
28331                         NametagColor     color.NRGBA
28332                         FaceRotateSpeed  float32 // in degrees per second.
28333                         Infotext         string
28334                         Itemstring       string
28335                         Glow             int8
28336                         MaxBreath        uint16  // Player only.
28337                         EyeHeight        float32 // Player only.
28338                         ZoomFOV          float32 // in degrees. Player only.
28339                         UseTextureAlpha  bool
28340                         DmgTextureMod    Texture // suffix
28341                         Shaded           bool
28342                         ShowOnMinimap    bool
28343                         NametagBG        color.NRGBA
28344                 }))(obj)).FaceRotateSpeed
28345                 write32(w, math.Float32bits(x))
28346         }
28347         if len(([]byte((*(*(struct {
28348                 MaxHP            uint16 // Player only.
28349                 CollideWithNodes bool
28350                 Weight           float32 // deprecated
28351                 ColBox, SelBox   Box
28352                 Pointable        bool
28353                 Visual           string
28354                 VisualSize       [3]float32
28355                 Textures         []Texture
28356                 SpriteSheetSize  [2]int16 // in sprites.
28357                 SpritePos        [2]int16 // in sprite sheet.
28358                 Visible          bool
28359                 MakeFootstepSnds bool
28360                 RotateSpeed      float32 // in radians per second.
28361                 Mesh             string
28362                 Colors           []color.NRGBA
28363                 CollideWithAOs   bool
28364                 StepHeight       float32
28365                 FaceRotateDir    bool
28366                 FaceRotateDirOff float32 // in degrees.
28367                 BackfaceCull     bool
28368                 Nametag          string
28369                 NametagColor     color.NRGBA
28370                 FaceRotateSpeed  float32 // in degrees per second.
28371                 Infotext         string
28372                 Itemstring       string
28373                 Glow             int8
28374                 MaxBreath        uint16  // Player only.
28375                 EyeHeight        float32 // Player only.
28376                 ZoomFOV          float32 // in degrees. Player only.
28377                 UseTextureAlpha  bool
28378                 DmgTextureMod    Texture // suffix
28379                 Shaded           bool
28380                 ShowOnMinimap    bool
28381                 NametagBG        color.NRGBA
28382         }))(obj)).Infotext))) > math.MaxUint16 {
28383                 chk(ErrTooLong)
28384         }
28385         {
28386                 x := uint16(len(([]byte((*(*(struct {
28387                         MaxHP            uint16 // Player only.
28388                         CollideWithNodes bool
28389                         Weight           float32 // deprecated
28390                         ColBox, SelBox   Box
28391                         Pointable        bool
28392                         Visual           string
28393                         VisualSize       [3]float32
28394                         Textures         []Texture
28395                         SpriteSheetSize  [2]int16 // in sprites.
28396                         SpritePos        [2]int16 // in sprite sheet.
28397                         Visible          bool
28398                         MakeFootstepSnds bool
28399                         RotateSpeed      float32 // in radians per second.
28400                         Mesh             string
28401                         Colors           []color.NRGBA
28402                         CollideWithAOs   bool
28403                         StepHeight       float32
28404                         FaceRotateDir    bool
28405                         FaceRotateDirOff float32 // in degrees.
28406                         BackfaceCull     bool
28407                         Nametag          string
28408                         NametagColor     color.NRGBA
28409                         FaceRotateSpeed  float32 // in degrees per second.
28410                         Infotext         string
28411                         Itemstring       string
28412                         Glow             int8
28413                         MaxBreath        uint16  // Player only.
28414                         EyeHeight        float32 // Player only.
28415                         ZoomFOV          float32 // in degrees. Player only.
28416                         UseTextureAlpha  bool
28417                         DmgTextureMod    Texture // suffix
28418                         Shaded           bool
28419                         ShowOnMinimap    bool
28420                         NametagBG        color.NRGBA
28421                 }))(obj)).Infotext))))
28422                 write16(w, uint16(x))
28423         }
28424         {
28425                 _, err := w.Write(([]byte((*(*(struct {
28426                         MaxHP            uint16 // Player only.
28427                         CollideWithNodes bool
28428                         Weight           float32 // deprecated
28429                         ColBox, SelBox   Box
28430                         Pointable        bool
28431                         Visual           string
28432                         VisualSize       [3]float32
28433                         Textures         []Texture
28434                         SpriteSheetSize  [2]int16 // in sprites.
28435                         SpritePos        [2]int16 // in sprite sheet.
28436                         Visible          bool
28437                         MakeFootstepSnds bool
28438                         RotateSpeed      float32 // in radians per second.
28439                         Mesh             string
28440                         Colors           []color.NRGBA
28441                         CollideWithAOs   bool
28442                         StepHeight       float32
28443                         FaceRotateDir    bool
28444                         FaceRotateDirOff float32 // in degrees.
28445                         BackfaceCull     bool
28446                         Nametag          string
28447                         NametagColor     color.NRGBA
28448                         FaceRotateSpeed  float32 // in degrees per second.
28449                         Infotext         string
28450                         Itemstring       string
28451                         Glow             int8
28452                         MaxBreath        uint16  // Player only.
28453                         EyeHeight        float32 // Player only.
28454                         ZoomFOV          float32 // in degrees. Player only.
28455                         UseTextureAlpha  bool
28456                         DmgTextureMod    Texture // suffix
28457                         Shaded           bool
28458                         ShowOnMinimap    bool
28459                         NametagBG        color.NRGBA
28460                 }))(obj)).Infotext))[:])
28461                 chk(err)
28462         }
28463         if len(([]byte((*(*(struct {
28464                 MaxHP            uint16 // Player only.
28465                 CollideWithNodes bool
28466                 Weight           float32 // deprecated
28467                 ColBox, SelBox   Box
28468                 Pointable        bool
28469                 Visual           string
28470                 VisualSize       [3]float32
28471                 Textures         []Texture
28472                 SpriteSheetSize  [2]int16 // in sprites.
28473                 SpritePos        [2]int16 // in sprite sheet.
28474                 Visible          bool
28475                 MakeFootstepSnds bool
28476                 RotateSpeed      float32 // in radians per second.
28477                 Mesh             string
28478                 Colors           []color.NRGBA
28479                 CollideWithAOs   bool
28480                 StepHeight       float32
28481                 FaceRotateDir    bool
28482                 FaceRotateDirOff float32 // in degrees.
28483                 BackfaceCull     bool
28484                 Nametag          string
28485                 NametagColor     color.NRGBA
28486                 FaceRotateSpeed  float32 // in degrees per second.
28487                 Infotext         string
28488                 Itemstring       string
28489                 Glow             int8
28490                 MaxBreath        uint16  // Player only.
28491                 EyeHeight        float32 // Player only.
28492                 ZoomFOV          float32 // in degrees. Player only.
28493                 UseTextureAlpha  bool
28494                 DmgTextureMod    Texture // suffix
28495                 Shaded           bool
28496                 ShowOnMinimap    bool
28497                 NametagBG        color.NRGBA
28498         }))(obj)).Itemstring))) > math.MaxUint16 {
28499                 chk(ErrTooLong)
28500         }
28501         {
28502                 x := uint16(len(([]byte((*(*(struct {
28503                         MaxHP            uint16 // Player only.
28504                         CollideWithNodes bool
28505                         Weight           float32 // deprecated
28506                         ColBox, SelBox   Box
28507                         Pointable        bool
28508                         Visual           string
28509                         VisualSize       [3]float32
28510                         Textures         []Texture
28511                         SpriteSheetSize  [2]int16 // in sprites.
28512                         SpritePos        [2]int16 // in sprite sheet.
28513                         Visible          bool
28514                         MakeFootstepSnds bool
28515                         RotateSpeed      float32 // in radians per second.
28516                         Mesh             string
28517                         Colors           []color.NRGBA
28518                         CollideWithAOs   bool
28519                         StepHeight       float32
28520                         FaceRotateDir    bool
28521                         FaceRotateDirOff float32 // in degrees.
28522                         BackfaceCull     bool
28523                         Nametag          string
28524                         NametagColor     color.NRGBA
28525                         FaceRotateSpeed  float32 // in degrees per second.
28526                         Infotext         string
28527                         Itemstring       string
28528                         Glow             int8
28529                         MaxBreath        uint16  // Player only.
28530                         EyeHeight        float32 // Player only.
28531                         ZoomFOV          float32 // in degrees. Player only.
28532                         UseTextureAlpha  bool
28533                         DmgTextureMod    Texture // suffix
28534                         Shaded           bool
28535                         ShowOnMinimap    bool
28536                         NametagBG        color.NRGBA
28537                 }))(obj)).Itemstring))))
28538                 write16(w, uint16(x))
28539         }
28540         {
28541                 _, err := w.Write(([]byte((*(*(struct {
28542                         MaxHP            uint16 // Player only.
28543                         CollideWithNodes bool
28544                         Weight           float32 // deprecated
28545                         ColBox, SelBox   Box
28546                         Pointable        bool
28547                         Visual           string
28548                         VisualSize       [3]float32
28549                         Textures         []Texture
28550                         SpriteSheetSize  [2]int16 // in sprites.
28551                         SpritePos        [2]int16 // in sprite sheet.
28552                         Visible          bool
28553                         MakeFootstepSnds bool
28554                         RotateSpeed      float32 // in radians per second.
28555                         Mesh             string
28556                         Colors           []color.NRGBA
28557                         CollideWithAOs   bool
28558                         StepHeight       float32
28559                         FaceRotateDir    bool
28560                         FaceRotateDirOff float32 // in degrees.
28561                         BackfaceCull     bool
28562                         Nametag          string
28563                         NametagColor     color.NRGBA
28564                         FaceRotateSpeed  float32 // in degrees per second.
28565                         Infotext         string
28566                         Itemstring       string
28567                         Glow             int8
28568                         MaxBreath        uint16  // Player only.
28569                         EyeHeight        float32 // Player only.
28570                         ZoomFOV          float32 // in degrees. Player only.
28571                         UseTextureAlpha  bool
28572                         DmgTextureMod    Texture // suffix
28573                         Shaded           bool
28574                         ShowOnMinimap    bool
28575                         NametagBG        color.NRGBA
28576                 }))(obj)).Itemstring))[:])
28577                 chk(err)
28578         }
28579         {
28580                 x := (*(*(struct {
28581                         MaxHP            uint16 // Player only.
28582                         CollideWithNodes bool
28583                         Weight           float32 // deprecated
28584                         ColBox, SelBox   Box
28585                         Pointable        bool
28586                         Visual           string
28587                         VisualSize       [3]float32
28588                         Textures         []Texture
28589                         SpriteSheetSize  [2]int16 // in sprites.
28590                         SpritePos        [2]int16 // in sprite sheet.
28591                         Visible          bool
28592                         MakeFootstepSnds bool
28593                         RotateSpeed      float32 // in radians per second.
28594                         Mesh             string
28595                         Colors           []color.NRGBA
28596                         CollideWithAOs   bool
28597                         StepHeight       float32
28598                         FaceRotateDir    bool
28599                         FaceRotateDirOff float32 // in degrees.
28600                         BackfaceCull     bool
28601                         Nametag          string
28602                         NametagColor     color.NRGBA
28603                         FaceRotateSpeed  float32 // in degrees per second.
28604                         Infotext         string
28605                         Itemstring       string
28606                         Glow             int8
28607                         MaxBreath        uint16  // Player only.
28608                         EyeHeight        float32 // Player only.
28609                         ZoomFOV          float32 // in degrees. Player only.
28610                         UseTextureAlpha  bool
28611                         DmgTextureMod    Texture // suffix
28612                         Shaded           bool
28613                         ShowOnMinimap    bool
28614                         NametagBG        color.NRGBA
28615                 }))(obj)).Glow
28616                 write8(w, uint8(x))
28617         }
28618         {
28619                 x := (*(*(struct {
28620                         MaxHP            uint16 // Player only.
28621                         CollideWithNodes bool
28622                         Weight           float32 // deprecated
28623                         ColBox, SelBox   Box
28624                         Pointable        bool
28625                         Visual           string
28626                         VisualSize       [3]float32
28627                         Textures         []Texture
28628                         SpriteSheetSize  [2]int16 // in sprites.
28629                         SpritePos        [2]int16 // in sprite sheet.
28630                         Visible          bool
28631                         MakeFootstepSnds bool
28632                         RotateSpeed      float32 // in radians per second.
28633                         Mesh             string
28634                         Colors           []color.NRGBA
28635                         CollideWithAOs   bool
28636                         StepHeight       float32
28637                         FaceRotateDir    bool
28638                         FaceRotateDirOff float32 // in degrees.
28639                         BackfaceCull     bool
28640                         Nametag          string
28641                         NametagColor     color.NRGBA
28642                         FaceRotateSpeed  float32 // in degrees per second.
28643                         Infotext         string
28644                         Itemstring       string
28645                         Glow             int8
28646                         MaxBreath        uint16  // Player only.
28647                         EyeHeight        float32 // Player only.
28648                         ZoomFOV          float32 // in degrees. Player only.
28649                         UseTextureAlpha  bool
28650                         DmgTextureMod    Texture // suffix
28651                         Shaded           bool
28652                         ShowOnMinimap    bool
28653                         NametagBG        color.NRGBA
28654                 }))(obj)).MaxBreath
28655                 write16(w, uint16(x))
28656         }
28657         {
28658                 x := (*(*(struct {
28659                         MaxHP            uint16 // Player only.
28660                         CollideWithNodes bool
28661                         Weight           float32 // deprecated
28662                         ColBox, SelBox   Box
28663                         Pointable        bool
28664                         Visual           string
28665                         VisualSize       [3]float32
28666                         Textures         []Texture
28667                         SpriteSheetSize  [2]int16 // in sprites.
28668                         SpritePos        [2]int16 // in sprite sheet.
28669                         Visible          bool
28670                         MakeFootstepSnds bool
28671                         RotateSpeed      float32 // in radians per second.
28672                         Mesh             string
28673                         Colors           []color.NRGBA
28674                         CollideWithAOs   bool
28675                         StepHeight       float32
28676                         FaceRotateDir    bool
28677                         FaceRotateDirOff float32 // in degrees.
28678                         BackfaceCull     bool
28679                         Nametag          string
28680                         NametagColor     color.NRGBA
28681                         FaceRotateSpeed  float32 // in degrees per second.
28682                         Infotext         string
28683                         Itemstring       string
28684                         Glow             int8
28685                         MaxBreath        uint16  // Player only.
28686                         EyeHeight        float32 // Player only.
28687                         ZoomFOV          float32 // in degrees. Player only.
28688                         UseTextureAlpha  bool
28689                         DmgTextureMod    Texture // suffix
28690                         Shaded           bool
28691                         ShowOnMinimap    bool
28692                         NametagBG        color.NRGBA
28693                 }))(obj)).EyeHeight
28694                 write32(w, math.Float32bits(x))
28695         }
28696         {
28697                 x := (*(*(struct {
28698                         MaxHP            uint16 // Player only.
28699                         CollideWithNodes bool
28700                         Weight           float32 // deprecated
28701                         ColBox, SelBox   Box
28702                         Pointable        bool
28703                         Visual           string
28704                         VisualSize       [3]float32
28705                         Textures         []Texture
28706                         SpriteSheetSize  [2]int16 // in sprites.
28707                         SpritePos        [2]int16 // in sprite sheet.
28708                         Visible          bool
28709                         MakeFootstepSnds bool
28710                         RotateSpeed      float32 // in radians per second.
28711                         Mesh             string
28712                         Colors           []color.NRGBA
28713                         CollideWithAOs   bool
28714                         StepHeight       float32
28715                         FaceRotateDir    bool
28716                         FaceRotateDirOff float32 // in degrees.
28717                         BackfaceCull     bool
28718                         Nametag          string
28719                         NametagColor     color.NRGBA
28720                         FaceRotateSpeed  float32 // in degrees per second.
28721                         Infotext         string
28722                         Itemstring       string
28723                         Glow             int8
28724                         MaxBreath        uint16  // Player only.
28725                         EyeHeight        float32 // Player only.
28726                         ZoomFOV          float32 // in degrees. Player only.
28727                         UseTextureAlpha  bool
28728                         DmgTextureMod    Texture // suffix
28729                         Shaded           bool
28730                         ShowOnMinimap    bool
28731                         NametagBG        color.NRGBA
28732                 }))(obj)).ZoomFOV
28733                 write32(w, math.Float32bits(x))
28734         }
28735         {
28736                 x := (*(*(struct {
28737                         MaxHP            uint16 // Player only.
28738                         CollideWithNodes bool
28739                         Weight           float32 // deprecated
28740                         ColBox, SelBox   Box
28741                         Pointable        bool
28742                         Visual           string
28743                         VisualSize       [3]float32
28744                         Textures         []Texture
28745                         SpriteSheetSize  [2]int16 // in sprites.
28746                         SpritePos        [2]int16 // in sprite sheet.
28747                         Visible          bool
28748                         MakeFootstepSnds bool
28749                         RotateSpeed      float32 // in radians per second.
28750                         Mesh             string
28751                         Colors           []color.NRGBA
28752                         CollideWithAOs   bool
28753                         StepHeight       float32
28754                         FaceRotateDir    bool
28755                         FaceRotateDirOff float32 // in degrees.
28756                         BackfaceCull     bool
28757                         Nametag          string
28758                         NametagColor     color.NRGBA
28759                         FaceRotateSpeed  float32 // in degrees per second.
28760                         Infotext         string
28761                         Itemstring       string
28762                         Glow             int8
28763                         MaxBreath        uint16  // Player only.
28764                         EyeHeight        float32 // Player only.
28765                         ZoomFOV          float32 // in degrees. Player only.
28766                         UseTextureAlpha  bool
28767                         DmgTextureMod    Texture // suffix
28768                         Shaded           bool
28769                         ShowOnMinimap    bool
28770                         NametagBG        color.NRGBA
28771                 }))(obj)).UseTextureAlpha
28772                 if x {
28773                         write8(w, 1)
28774                 } else {
28775                         write8(w, 0)
28776                 }
28777         }
28778         if err := pcall(func() {
28779                 ((*(*(struct {
28780                         MaxHP            uint16 // Player only.
28781                         CollideWithNodes bool
28782                         Weight           float32 // deprecated
28783                         ColBox, SelBox   Box
28784                         Pointable        bool
28785                         Visual           string
28786                         VisualSize       [3]float32
28787                         Textures         []Texture
28788                         SpriteSheetSize  [2]int16 // in sprites.
28789                         SpritePos        [2]int16 // in sprite sheet.
28790                         Visible          bool
28791                         MakeFootstepSnds bool
28792                         RotateSpeed      float32 // in radians per second.
28793                         Mesh             string
28794                         Colors           []color.NRGBA
28795                         CollideWithAOs   bool
28796                         StepHeight       float32
28797                         FaceRotateDir    bool
28798                         FaceRotateDirOff float32 // in degrees.
28799                         BackfaceCull     bool
28800                         Nametag          string
28801                         NametagColor     color.NRGBA
28802                         FaceRotateSpeed  float32 // in degrees per second.
28803                         Infotext         string
28804                         Itemstring       string
28805                         Glow             int8
28806                         MaxBreath        uint16  // Player only.
28807                         EyeHeight        float32 // Player only.
28808                         ZoomFOV          float32 // in degrees. Player only.
28809                         UseTextureAlpha  bool
28810                         DmgTextureMod    Texture // suffix
28811                         Shaded           bool
28812                         ShowOnMinimap    bool
28813                         NametagBG        color.NRGBA
28814                 }))(obj)).DmgTextureMod).serialize(w)
28815         }); err != nil {
28816                 if err == io.EOF {
28817                         chk(io.EOF)
28818                 }
28819                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
28820         }
28821         {
28822                 x := (*(*(struct {
28823                         MaxHP            uint16 // Player only.
28824                         CollideWithNodes bool
28825                         Weight           float32 // deprecated
28826                         ColBox, SelBox   Box
28827                         Pointable        bool
28828                         Visual           string
28829                         VisualSize       [3]float32
28830                         Textures         []Texture
28831                         SpriteSheetSize  [2]int16 // in sprites.
28832                         SpritePos        [2]int16 // in sprite sheet.
28833                         Visible          bool
28834                         MakeFootstepSnds bool
28835                         RotateSpeed      float32 // in radians per second.
28836                         Mesh             string
28837                         Colors           []color.NRGBA
28838                         CollideWithAOs   bool
28839                         StepHeight       float32
28840                         FaceRotateDir    bool
28841                         FaceRotateDirOff float32 // in degrees.
28842                         BackfaceCull     bool
28843                         Nametag          string
28844                         NametagColor     color.NRGBA
28845                         FaceRotateSpeed  float32 // in degrees per second.
28846                         Infotext         string
28847                         Itemstring       string
28848                         Glow             int8
28849                         MaxBreath        uint16  // Player only.
28850                         EyeHeight        float32 // Player only.
28851                         ZoomFOV          float32 // in degrees. Player only.
28852                         UseTextureAlpha  bool
28853                         DmgTextureMod    Texture // suffix
28854                         Shaded           bool
28855                         ShowOnMinimap    bool
28856                         NametagBG        color.NRGBA
28857                 }))(obj)).Shaded
28858                 if x {
28859                         write8(w, 1)
28860                 } else {
28861                         write8(w, 0)
28862                 }
28863         }
28864         {
28865                 x := (*(*(struct {
28866                         MaxHP            uint16 // Player only.
28867                         CollideWithNodes bool
28868                         Weight           float32 // deprecated
28869                         ColBox, SelBox   Box
28870                         Pointable        bool
28871                         Visual           string
28872                         VisualSize       [3]float32
28873                         Textures         []Texture
28874                         SpriteSheetSize  [2]int16 // in sprites.
28875                         SpritePos        [2]int16 // in sprite sheet.
28876                         Visible          bool
28877                         MakeFootstepSnds bool
28878                         RotateSpeed      float32 // in radians per second.
28879                         Mesh             string
28880                         Colors           []color.NRGBA
28881                         CollideWithAOs   bool
28882                         StepHeight       float32
28883                         FaceRotateDir    bool
28884                         FaceRotateDirOff float32 // in degrees.
28885                         BackfaceCull     bool
28886                         Nametag          string
28887                         NametagColor     color.NRGBA
28888                         FaceRotateSpeed  float32 // in degrees per second.
28889                         Infotext         string
28890                         Itemstring       string
28891                         Glow             int8
28892                         MaxBreath        uint16  // Player only.
28893                         EyeHeight        float32 // Player only.
28894                         ZoomFOV          float32 // in degrees. Player only.
28895                         UseTextureAlpha  bool
28896                         DmgTextureMod    Texture // suffix
28897                         Shaded           bool
28898                         ShowOnMinimap    bool
28899                         NametagBG        color.NRGBA
28900                 }))(obj)).ShowOnMinimap
28901                 if x {
28902                         write8(w, 1)
28903                 } else {
28904                         write8(w, 0)
28905                 }
28906         }
28907         {
28908                 x := (*(*(struct {
28909                         MaxHP            uint16 // Player only.
28910                         CollideWithNodes bool
28911                         Weight           float32 // deprecated
28912                         ColBox, SelBox   Box
28913                         Pointable        bool
28914                         Visual           string
28915                         VisualSize       [3]float32
28916                         Textures         []Texture
28917                         SpriteSheetSize  [2]int16 // in sprites.
28918                         SpritePos        [2]int16 // in sprite sheet.
28919                         Visible          bool
28920                         MakeFootstepSnds bool
28921                         RotateSpeed      float32 // in radians per second.
28922                         Mesh             string
28923                         Colors           []color.NRGBA
28924                         CollideWithAOs   bool
28925                         StepHeight       float32
28926                         FaceRotateDir    bool
28927                         FaceRotateDirOff float32 // in degrees.
28928                         BackfaceCull     bool
28929                         Nametag          string
28930                         NametagColor     color.NRGBA
28931                         FaceRotateSpeed  float32 // in degrees per second.
28932                         Infotext         string
28933                         Itemstring       string
28934                         Glow             int8
28935                         MaxBreath        uint16  // Player only.
28936                         EyeHeight        float32 // Player only.
28937                         ZoomFOV          float32 // in degrees. Player only.
28938                         UseTextureAlpha  bool
28939                         DmgTextureMod    Texture // suffix
28940                         Shaded           bool
28941                         ShowOnMinimap    bool
28942                         NametagBG        color.NRGBA
28943                 }))(obj)).NametagBG
28944                 w.Write([]byte{x.A, x.R, x.G, x.B})
28945         }
28946 }
28947
28948 func (obj *AOProps) deserialize(r io.Reader) {
28949         {
28950                 var local339 uint8
28951                 local340 := uint8(4)
28952                 {
28953                         p := &local339
28954                         *p = read8(r)
28955                 }
28956                 if local339 != local340 {
28957                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local339))
28958                 }
28959         }
28960         {
28961                 p := &(*(*(struct {
28962                         MaxHP            uint16 // Player only.
28963                         CollideWithNodes bool
28964                         Weight           float32 // deprecated
28965                         ColBox, SelBox   Box
28966                         Pointable        bool
28967                         Visual           string
28968                         VisualSize       [3]float32
28969                         Textures         []Texture
28970                         SpriteSheetSize  [2]int16 // in sprites.
28971                         SpritePos        [2]int16 // in sprite sheet.
28972                         Visible          bool
28973                         MakeFootstepSnds bool
28974                         RotateSpeed      float32 // in radians per second.
28975                         Mesh             string
28976                         Colors           []color.NRGBA
28977                         CollideWithAOs   bool
28978                         StepHeight       float32
28979                         FaceRotateDir    bool
28980                         FaceRotateDirOff float32 // in degrees.
28981                         BackfaceCull     bool
28982                         Nametag          string
28983                         NametagColor     color.NRGBA
28984                         FaceRotateSpeed  float32 // in degrees per second.
28985                         Infotext         string
28986                         Itemstring       string
28987                         Glow             int8
28988                         MaxBreath        uint16  // Player only.
28989                         EyeHeight        float32 // Player only.
28990                         ZoomFOV          float32 // in degrees. Player only.
28991                         UseTextureAlpha  bool
28992                         DmgTextureMod    Texture // suffix
28993                         Shaded           bool
28994                         ShowOnMinimap    bool
28995                         NametagBG        color.NRGBA
28996                 }))(obj)).MaxHP
28997                 *p = read16(r)
28998         }
28999         {
29000                 p := &(*(*(struct {
29001                         MaxHP            uint16 // Player only.
29002                         CollideWithNodes bool
29003                         Weight           float32 // deprecated
29004                         ColBox, SelBox   Box
29005                         Pointable        bool
29006                         Visual           string
29007                         VisualSize       [3]float32
29008                         Textures         []Texture
29009                         SpriteSheetSize  [2]int16 // in sprites.
29010                         SpritePos        [2]int16 // in sprite sheet.
29011                         Visible          bool
29012                         MakeFootstepSnds bool
29013                         RotateSpeed      float32 // in radians per second.
29014                         Mesh             string
29015                         Colors           []color.NRGBA
29016                         CollideWithAOs   bool
29017                         StepHeight       float32
29018                         FaceRotateDir    bool
29019                         FaceRotateDirOff float32 // in degrees.
29020                         BackfaceCull     bool
29021                         Nametag          string
29022                         NametagColor     color.NRGBA
29023                         FaceRotateSpeed  float32 // in degrees per second.
29024                         Infotext         string
29025                         Itemstring       string
29026                         Glow             int8
29027                         MaxBreath        uint16  // Player only.
29028                         EyeHeight        float32 // Player only.
29029                         ZoomFOV          float32 // in degrees. Player only.
29030                         UseTextureAlpha  bool
29031                         DmgTextureMod    Texture // suffix
29032                         Shaded           bool
29033                         ShowOnMinimap    bool
29034                         NametagBG        color.NRGBA
29035                 }))(obj)).CollideWithNodes
29036                 switch n := read8(r); n {
29037                 case 0:
29038                         *p = false
29039                 case 1:
29040                         *p = true
29041                 default:
29042                         chk(fmt.Errorf("invalid bool: %d", n))
29043                 }
29044         }
29045         {
29046                 p := &(*(*(struct {
29047                         MaxHP            uint16 // Player only.
29048                         CollideWithNodes bool
29049                         Weight           float32 // deprecated
29050                         ColBox, SelBox   Box
29051                         Pointable        bool
29052                         Visual           string
29053                         VisualSize       [3]float32
29054                         Textures         []Texture
29055                         SpriteSheetSize  [2]int16 // in sprites.
29056                         SpritePos        [2]int16 // in sprite sheet.
29057                         Visible          bool
29058                         MakeFootstepSnds bool
29059                         RotateSpeed      float32 // in radians per second.
29060                         Mesh             string
29061                         Colors           []color.NRGBA
29062                         CollideWithAOs   bool
29063                         StepHeight       float32
29064                         FaceRotateDir    bool
29065                         FaceRotateDirOff float32 // in degrees.
29066                         BackfaceCull     bool
29067                         Nametag          string
29068                         NametagColor     color.NRGBA
29069                         FaceRotateSpeed  float32 // in degrees per second.
29070                         Infotext         string
29071                         Itemstring       string
29072                         Glow             int8
29073                         MaxBreath        uint16  // Player only.
29074                         EyeHeight        float32 // Player only.
29075                         ZoomFOV          float32 // in degrees. Player only.
29076                         UseTextureAlpha  bool
29077                         DmgTextureMod    Texture // suffix
29078                         Shaded           bool
29079                         ShowOnMinimap    bool
29080                         NametagBG        color.NRGBA
29081                 }))(obj)).Weight
29082                 *p = math.Float32frombits(read32(r))
29083         }
29084         if err := pcall(func() {
29085                 ((*(*(struct {
29086                         MaxHP            uint16 // Player only.
29087                         CollideWithNodes bool
29088                         Weight           float32 // deprecated
29089                         ColBox, SelBox   Box
29090                         Pointable        bool
29091                         Visual           string
29092                         VisualSize       [3]float32
29093                         Textures         []Texture
29094                         SpriteSheetSize  [2]int16 // in sprites.
29095                         SpritePos        [2]int16 // in sprite sheet.
29096                         Visible          bool
29097                         MakeFootstepSnds bool
29098                         RotateSpeed      float32 // in radians per second.
29099                         Mesh             string
29100                         Colors           []color.NRGBA
29101                         CollideWithAOs   bool
29102                         StepHeight       float32
29103                         FaceRotateDir    bool
29104                         FaceRotateDirOff float32 // in degrees.
29105                         BackfaceCull     bool
29106                         Nametag          string
29107                         NametagColor     color.NRGBA
29108                         FaceRotateSpeed  float32 // in degrees per second.
29109                         Infotext         string
29110                         Itemstring       string
29111                         Glow             int8
29112                         MaxBreath        uint16  // Player only.
29113                         EyeHeight        float32 // Player only.
29114                         ZoomFOV          float32 // in degrees. Player only.
29115                         UseTextureAlpha  bool
29116                         DmgTextureMod    Texture // suffix
29117                         Shaded           bool
29118                         ShowOnMinimap    bool
29119                         NametagBG        color.NRGBA
29120                 }))(obj)).ColBox).deserialize(r)
29121         }); err != nil {
29122                 if err == io.EOF {
29123                         chk(io.EOF)
29124                 }
29125                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
29126         }
29127         if err := pcall(func() {
29128                 ((*(*(struct {
29129                         MaxHP            uint16 // Player only.
29130                         CollideWithNodes bool
29131                         Weight           float32 // deprecated
29132                         ColBox, SelBox   Box
29133                         Pointable        bool
29134                         Visual           string
29135                         VisualSize       [3]float32
29136                         Textures         []Texture
29137                         SpriteSheetSize  [2]int16 // in sprites.
29138                         SpritePos        [2]int16 // in sprite sheet.
29139                         Visible          bool
29140                         MakeFootstepSnds bool
29141                         RotateSpeed      float32 // in radians per second.
29142                         Mesh             string
29143                         Colors           []color.NRGBA
29144                         CollideWithAOs   bool
29145                         StepHeight       float32
29146                         FaceRotateDir    bool
29147                         FaceRotateDirOff float32 // in degrees.
29148                         BackfaceCull     bool
29149                         Nametag          string
29150                         NametagColor     color.NRGBA
29151                         FaceRotateSpeed  float32 // in degrees per second.
29152                         Infotext         string
29153                         Itemstring       string
29154                         Glow             int8
29155                         MaxBreath        uint16  // Player only.
29156                         EyeHeight        float32 // Player only.
29157                         ZoomFOV          float32 // in degrees. Player only.
29158                         UseTextureAlpha  bool
29159                         DmgTextureMod    Texture // suffix
29160                         Shaded           bool
29161                         ShowOnMinimap    bool
29162                         NametagBG        color.NRGBA
29163                 }))(obj)).SelBox).deserialize(r)
29164         }); err != nil {
29165                 if err == io.EOF {
29166                         chk(io.EOF)
29167                 }
29168                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
29169         }
29170         {
29171                 p := &(*(*(struct {
29172                         MaxHP            uint16 // Player only.
29173                         CollideWithNodes bool
29174                         Weight           float32 // deprecated
29175                         ColBox, SelBox   Box
29176                         Pointable        bool
29177                         Visual           string
29178                         VisualSize       [3]float32
29179                         Textures         []Texture
29180                         SpriteSheetSize  [2]int16 // in sprites.
29181                         SpritePos        [2]int16 // in sprite sheet.
29182                         Visible          bool
29183                         MakeFootstepSnds bool
29184                         RotateSpeed      float32 // in radians per second.
29185                         Mesh             string
29186                         Colors           []color.NRGBA
29187                         CollideWithAOs   bool
29188                         StepHeight       float32
29189                         FaceRotateDir    bool
29190                         FaceRotateDirOff float32 // in degrees.
29191                         BackfaceCull     bool
29192                         Nametag          string
29193                         NametagColor     color.NRGBA
29194                         FaceRotateSpeed  float32 // in degrees per second.
29195                         Infotext         string
29196                         Itemstring       string
29197                         Glow             int8
29198                         MaxBreath        uint16  // Player only.
29199                         EyeHeight        float32 // Player only.
29200                         ZoomFOV          float32 // in degrees. Player only.
29201                         UseTextureAlpha  bool
29202                         DmgTextureMod    Texture // suffix
29203                         Shaded           bool
29204                         ShowOnMinimap    bool
29205                         NametagBG        color.NRGBA
29206                 }))(obj)).Pointable
29207                 switch n := read8(r); n {
29208                 case 0:
29209                         *p = false
29210                 case 1:
29211                         *p = true
29212                 default:
29213                         chk(fmt.Errorf("invalid bool: %d", n))
29214                 }
29215         }
29216         var local341 []uint8
29217         var local342 uint16
29218         {
29219                 p := &local342
29220                 *p = read16(r)
29221         }
29222         (local341) = make([]uint8, local342)
29223         {
29224                 _, err := io.ReadFull(r, (local341)[:])
29225                 chk(err)
29226         }
29227         ((*(*(struct {
29228                 MaxHP            uint16 // Player only.
29229                 CollideWithNodes bool
29230                 Weight           float32 // deprecated
29231                 ColBox, SelBox   Box
29232                 Pointable        bool
29233                 Visual           string
29234                 VisualSize       [3]float32
29235                 Textures         []Texture
29236                 SpriteSheetSize  [2]int16 // in sprites.
29237                 SpritePos        [2]int16 // in sprite sheet.
29238                 Visible          bool
29239                 MakeFootstepSnds bool
29240                 RotateSpeed      float32 // in radians per second.
29241                 Mesh             string
29242                 Colors           []color.NRGBA
29243                 CollideWithAOs   bool
29244                 StepHeight       float32
29245                 FaceRotateDir    bool
29246                 FaceRotateDirOff float32 // in degrees.
29247                 BackfaceCull     bool
29248                 Nametag          string
29249                 NametagColor     color.NRGBA
29250                 FaceRotateSpeed  float32 // in degrees per second.
29251                 Infotext         string
29252                 Itemstring       string
29253                 Glow             int8
29254                 MaxBreath        uint16  // Player only.
29255                 EyeHeight        float32 // Player only.
29256                 ZoomFOV          float32 // in degrees. Player only.
29257                 UseTextureAlpha  bool
29258                 DmgTextureMod    Texture // suffix
29259                 Shaded           bool
29260                 ShowOnMinimap    bool
29261                 NametagBG        color.NRGBA
29262         }))(obj)).Visual) = string(local341)
29263         for local343 := range (*(*(struct {
29264                 MaxHP            uint16 // Player only.
29265                 CollideWithNodes bool
29266                 Weight           float32 // deprecated
29267                 ColBox, SelBox   Box
29268                 Pointable        bool
29269                 Visual           string
29270                 VisualSize       [3]float32
29271                 Textures         []Texture
29272                 SpriteSheetSize  [2]int16 // in sprites.
29273                 SpritePos        [2]int16 // in sprite sheet.
29274                 Visible          bool
29275                 MakeFootstepSnds bool
29276                 RotateSpeed      float32 // in radians per second.
29277                 Mesh             string
29278                 Colors           []color.NRGBA
29279                 CollideWithAOs   bool
29280                 StepHeight       float32
29281                 FaceRotateDir    bool
29282                 FaceRotateDirOff float32 // in degrees.
29283                 BackfaceCull     bool
29284                 Nametag          string
29285                 NametagColor     color.NRGBA
29286                 FaceRotateSpeed  float32 // in degrees per second.
29287                 Infotext         string
29288                 Itemstring       string
29289                 Glow             int8
29290                 MaxBreath        uint16  // Player only.
29291                 EyeHeight        float32 // Player only.
29292                 ZoomFOV          float32 // in degrees. Player only.
29293                 UseTextureAlpha  bool
29294                 DmgTextureMod    Texture // suffix
29295                 Shaded           bool
29296                 ShowOnMinimap    bool
29297                 NametagBG        color.NRGBA
29298         }))(obj)).VisualSize {
29299                 {
29300                         p := &((*(*(struct {
29301                                 MaxHP            uint16 // Player only.
29302                                 CollideWithNodes bool
29303                                 Weight           float32 // deprecated
29304                                 ColBox, SelBox   Box
29305                                 Pointable        bool
29306                                 Visual           string
29307                                 VisualSize       [3]float32
29308                                 Textures         []Texture
29309                                 SpriteSheetSize  [2]int16 // in sprites.
29310                                 SpritePos        [2]int16 // in sprite sheet.
29311                                 Visible          bool
29312                                 MakeFootstepSnds bool
29313                                 RotateSpeed      float32 // in radians per second.
29314                                 Mesh             string
29315                                 Colors           []color.NRGBA
29316                                 CollideWithAOs   bool
29317                                 StepHeight       float32
29318                                 FaceRotateDir    bool
29319                                 FaceRotateDirOff float32 // in degrees.
29320                                 BackfaceCull     bool
29321                                 Nametag          string
29322                                 NametagColor     color.NRGBA
29323                                 FaceRotateSpeed  float32 // in degrees per second.
29324                                 Infotext         string
29325                                 Itemstring       string
29326                                 Glow             int8
29327                                 MaxBreath        uint16  // Player only.
29328                                 EyeHeight        float32 // Player only.
29329                                 ZoomFOV          float32 // in degrees. Player only.
29330                                 UseTextureAlpha  bool
29331                                 DmgTextureMod    Texture // suffix
29332                                 Shaded           bool
29333                                 ShowOnMinimap    bool
29334                                 NametagBG        color.NRGBA
29335                         }))(obj)).VisualSize)[local343]
29336                         *p = math.Float32frombits(read32(r))
29337                 }
29338         }
29339         var local344 uint16
29340         {
29341                 p := &local344
29342                 *p = read16(r)
29343         }
29344         ((*(*(struct {
29345                 MaxHP            uint16 // Player only.
29346                 CollideWithNodes bool
29347                 Weight           float32 // deprecated
29348                 ColBox, SelBox   Box
29349                 Pointable        bool
29350                 Visual           string
29351                 VisualSize       [3]float32
29352                 Textures         []Texture
29353                 SpriteSheetSize  [2]int16 // in sprites.
29354                 SpritePos        [2]int16 // in sprite sheet.
29355                 Visible          bool
29356                 MakeFootstepSnds bool
29357                 RotateSpeed      float32 // in radians per second.
29358                 Mesh             string
29359                 Colors           []color.NRGBA
29360                 CollideWithAOs   bool
29361                 StepHeight       float32
29362                 FaceRotateDir    bool
29363                 FaceRotateDirOff float32 // in degrees.
29364                 BackfaceCull     bool
29365                 Nametag          string
29366                 NametagColor     color.NRGBA
29367                 FaceRotateSpeed  float32 // in degrees per second.
29368                 Infotext         string
29369                 Itemstring       string
29370                 Glow             int8
29371                 MaxBreath        uint16  // Player only.
29372                 EyeHeight        float32 // Player only.
29373                 ZoomFOV          float32 // in degrees. Player only.
29374                 UseTextureAlpha  bool
29375                 DmgTextureMod    Texture // suffix
29376                 Shaded           bool
29377                 ShowOnMinimap    bool
29378                 NametagBG        color.NRGBA
29379         }))(obj)).Textures) = make([]Texture, local344)
29380         for local345 := range (*(*(struct {
29381                 MaxHP            uint16 // Player only.
29382                 CollideWithNodes bool
29383                 Weight           float32 // deprecated
29384                 ColBox, SelBox   Box
29385                 Pointable        bool
29386                 Visual           string
29387                 VisualSize       [3]float32
29388                 Textures         []Texture
29389                 SpriteSheetSize  [2]int16 // in sprites.
29390                 SpritePos        [2]int16 // in sprite sheet.
29391                 Visible          bool
29392                 MakeFootstepSnds bool
29393                 RotateSpeed      float32 // in radians per second.
29394                 Mesh             string
29395                 Colors           []color.NRGBA
29396                 CollideWithAOs   bool
29397                 StepHeight       float32
29398                 FaceRotateDir    bool
29399                 FaceRotateDirOff float32 // in degrees.
29400                 BackfaceCull     bool
29401                 Nametag          string
29402                 NametagColor     color.NRGBA
29403                 FaceRotateSpeed  float32 // in degrees per second.
29404                 Infotext         string
29405                 Itemstring       string
29406                 Glow             int8
29407                 MaxBreath        uint16  // Player only.
29408                 EyeHeight        float32 // Player only.
29409                 ZoomFOV          float32 // in degrees. Player only.
29410                 UseTextureAlpha  bool
29411                 DmgTextureMod    Texture // suffix
29412                 Shaded           bool
29413                 ShowOnMinimap    bool
29414                 NametagBG        color.NRGBA
29415         }))(obj)).Textures {
29416                 if err := pcall(func() {
29417                         (((*(*(struct {
29418                                 MaxHP            uint16 // Player only.
29419                                 CollideWithNodes bool
29420                                 Weight           float32 // deprecated
29421                                 ColBox, SelBox   Box
29422                                 Pointable        bool
29423                                 Visual           string
29424                                 VisualSize       [3]float32
29425                                 Textures         []Texture
29426                                 SpriteSheetSize  [2]int16 // in sprites.
29427                                 SpritePos        [2]int16 // in sprite sheet.
29428                                 Visible          bool
29429                                 MakeFootstepSnds bool
29430                                 RotateSpeed      float32 // in radians per second.
29431                                 Mesh             string
29432                                 Colors           []color.NRGBA
29433                                 CollideWithAOs   bool
29434                                 StepHeight       float32
29435                                 FaceRotateDir    bool
29436                                 FaceRotateDirOff float32 // in degrees.
29437                                 BackfaceCull     bool
29438                                 Nametag          string
29439                                 NametagColor     color.NRGBA
29440                                 FaceRotateSpeed  float32 // in degrees per second.
29441                                 Infotext         string
29442                                 Itemstring       string
29443                                 Glow             int8
29444                                 MaxBreath        uint16  // Player only.
29445                                 EyeHeight        float32 // Player only.
29446                                 ZoomFOV          float32 // in degrees. Player only.
29447                                 UseTextureAlpha  bool
29448                                 DmgTextureMod    Texture // suffix
29449                                 Shaded           bool
29450                                 ShowOnMinimap    bool
29451                                 NametagBG        color.NRGBA
29452                         }))(obj)).Textures)[local345]).deserialize(r)
29453                 }); err != nil {
29454                         if err == io.EOF {
29455                                 chk(io.EOF)
29456                         }
29457                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
29458                 }
29459         }
29460         for local346 := range (*(*(struct {
29461                 MaxHP            uint16 // Player only.
29462                 CollideWithNodes bool
29463                 Weight           float32 // deprecated
29464                 ColBox, SelBox   Box
29465                 Pointable        bool
29466                 Visual           string
29467                 VisualSize       [3]float32
29468                 Textures         []Texture
29469                 SpriteSheetSize  [2]int16 // in sprites.
29470                 SpritePos        [2]int16 // in sprite sheet.
29471                 Visible          bool
29472                 MakeFootstepSnds bool
29473                 RotateSpeed      float32 // in radians per second.
29474                 Mesh             string
29475                 Colors           []color.NRGBA
29476                 CollideWithAOs   bool
29477                 StepHeight       float32
29478                 FaceRotateDir    bool
29479                 FaceRotateDirOff float32 // in degrees.
29480                 BackfaceCull     bool
29481                 Nametag          string
29482                 NametagColor     color.NRGBA
29483                 FaceRotateSpeed  float32 // in degrees per second.
29484                 Infotext         string
29485                 Itemstring       string
29486                 Glow             int8
29487                 MaxBreath        uint16  // Player only.
29488                 EyeHeight        float32 // Player only.
29489                 ZoomFOV          float32 // in degrees. Player only.
29490                 UseTextureAlpha  bool
29491                 DmgTextureMod    Texture // suffix
29492                 Shaded           bool
29493                 ShowOnMinimap    bool
29494                 NametagBG        color.NRGBA
29495         }))(obj)).SpriteSheetSize {
29496                 {
29497                         p := &((*(*(struct {
29498                                 MaxHP            uint16 // Player only.
29499                                 CollideWithNodes bool
29500                                 Weight           float32 // deprecated
29501                                 ColBox, SelBox   Box
29502                                 Pointable        bool
29503                                 Visual           string
29504                                 VisualSize       [3]float32
29505                                 Textures         []Texture
29506                                 SpriteSheetSize  [2]int16 // in sprites.
29507                                 SpritePos        [2]int16 // in sprite sheet.
29508                                 Visible          bool
29509                                 MakeFootstepSnds bool
29510                                 RotateSpeed      float32 // in radians per second.
29511                                 Mesh             string
29512                                 Colors           []color.NRGBA
29513                                 CollideWithAOs   bool
29514                                 StepHeight       float32
29515                                 FaceRotateDir    bool
29516                                 FaceRotateDirOff float32 // in degrees.
29517                                 BackfaceCull     bool
29518                                 Nametag          string
29519                                 NametagColor     color.NRGBA
29520                                 FaceRotateSpeed  float32 // in degrees per second.
29521                                 Infotext         string
29522                                 Itemstring       string
29523                                 Glow             int8
29524                                 MaxBreath        uint16  // Player only.
29525                                 EyeHeight        float32 // Player only.
29526                                 ZoomFOV          float32 // in degrees. Player only.
29527                                 UseTextureAlpha  bool
29528                                 DmgTextureMod    Texture // suffix
29529                                 Shaded           bool
29530                                 ShowOnMinimap    bool
29531                                 NametagBG        color.NRGBA
29532                         }))(obj)).SpriteSheetSize)[local346]
29533                         *p = int16(read16(r))
29534                 }
29535         }
29536         for local347 := range (*(*(struct {
29537                 MaxHP            uint16 // Player only.
29538                 CollideWithNodes bool
29539                 Weight           float32 // deprecated
29540                 ColBox, SelBox   Box
29541                 Pointable        bool
29542                 Visual           string
29543                 VisualSize       [3]float32
29544                 Textures         []Texture
29545                 SpriteSheetSize  [2]int16 // in sprites.
29546                 SpritePos        [2]int16 // in sprite sheet.
29547                 Visible          bool
29548                 MakeFootstepSnds bool
29549                 RotateSpeed      float32 // in radians per second.
29550                 Mesh             string
29551                 Colors           []color.NRGBA
29552                 CollideWithAOs   bool
29553                 StepHeight       float32
29554                 FaceRotateDir    bool
29555                 FaceRotateDirOff float32 // in degrees.
29556                 BackfaceCull     bool
29557                 Nametag          string
29558                 NametagColor     color.NRGBA
29559                 FaceRotateSpeed  float32 // in degrees per second.
29560                 Infotext         string
29561                 Itemstring       string
29562                 Glow             int8
29563                 MaxBreath        uint16  // Player only.
29564                 EyeHeight        float32 // Player only.
29565                 ZoomFOV          float32 // in degrees. Player only.
29566                 UseTextureAlpha  bool
29567                 DmgTextureMod    Texture // suffix
29568                 Shaded           bool
29569                 ShowOnMinimap    bool
29570                 NametagBG        color.NRGBA
29571         }))(obj)).SpritePos {
29572                 {
29573                         p := &((*(*(struct {
29574                                 MaxHP            uint16 // Player only.
29575                                 CollideWithNodes bool
29576                                 Weight           float32 // deprecated
29577                                 ColBox, SelBox   Box
29578                                 Pointable        bool
29579                                 Visual           string
29580                                 VisualSize       [3]float32
29581                                 Textures         []Texture
29582                                 SpriteSheetSize  [2]int16 // in sprites.
29583                                 SpritePos        [2]int16 // in sprite sheet.
29584                                 Visible          bool
29585                                 MakeFootstepSnds bool
29586                                 RotateSpeed      float32 // in radians per second.
29587                                 Mesh             string
29588                                 Colors           []color.NRGBA
29589                                 CollideWithAOs   bool
29590                                 StepHeight       float32
29591                                 FaceRotateDir    bool
29592                                 FaceRotateDirOff float32 // in degrees.
29593                                 BackfaceCull     bool
29594                                 Nametag          string
29595                                 NametagColor     color.NRGBA
29596                                 FaceRotateSpeed  float32 // in degrees per second.
29597                                 Infotext         string
29598                                 Itemstring       string
29599                                 Glow             int8
29600                                 MaxBreath        uint16  // Player only.
29601                                 EyeHeight        float32 // Player only.
29602                                 ZoomFOV          float32 // in degrees. Player only.
29603                                 UseTextureAlpha  bool
29604                                 DmgTextureMod    Texture // suffix
29605                                 Shaded           bool
29606                                 ShowOnMinimap    bool
29607                                 NametagBG        color.NRGBA
29608                         }))(obj)).SpritePos)[local347]
29609                         *p = int16(read16(r))
29610                 }
29611         }
29612         {
29613                 p := &(*(*(struct {
29614                         MaxHP            uint16 // Player only.
29615                         CollideWithNodes bool
29616                         Weight           float32 // deprecated
29617                         ColBox, SelBox   Box
29618                         Pointable        bool
29619                         Visual           string
29620                         VisualSize       [3]float32
29621                         Textures         []Texture
29622                         SpriteSheetSize  [2]int16 // in sprites.
29623                         SpritePos        [2]int16 // in sprite sheet.
29624                         Visible          bool
29625                         MakeFootstepSnds bool
29626                         RotateSpeed      float32 // in radians per second.
29627                         Mesh             string
29628                         Colors           []color.NRGBA
29629                         CollideWithAOs   bool
29630                         StepHeight       float32
29631                         FaceRotateDir    bool
29632                         FaceRotateDirOff float32 // in degrees.
29633                         BackfaceCull     bool
29634                         Nametag          string
29635                         NametagColor     color.NRGBA
29636                         FaceRotateSpeed  float32 // in degrees per second.
29637                         Infotext         string
29638                         Itemstring       string
29639                         Glow             int8
29640                         MaxBreath        uint16  // Player only.
29641                         EyeHeight        float32 // Player only.
29642                         ZoomFOV          float32 // in degrees. Player only.
29643                         UseTextureAlpha  bool
29644                         DmgTextureMod    Texture // suffix
29645                         Shaded           bool
29646                         ShowOnMinimap    bool
29647                         NametagBG        color.NRGBA
29648                 }))(obj)).Visible
29649                 switch n := read8(r); n {
29650                 case 0:
29651                         *p = false
29652                 case 1:
29653                         *p = true
29654                 default:
29655                         chk(fmt.Errorf("invalid bool: %d", n))
29656                 }
29657         }
29658         {
29659                 p := &(*(*(struct {
29660                         MaxHP            uint16 // Player only.
29661                         CollideWithNodes bool
29662                         Weight           float32 // deprecated
29663                         ColBox, SelBox   Box
29664                         Pointable        bool
29665                         Visual           string
29666                         VisualSize       [3]float32
29667                         Textures         []Texture
29668                         SpriteSheetSize  [2]int16 // in sprites.
29669                         SpritePos        [2]int16 // in sprite sheet.
29670                         Visible          bool
29671                         MakeFootstepSnds bool
29672                         RotateSpeed      float32 // in radians per second.
29673                         Mesh             string
29674                         Colors           []color.NRGBA
29675                         CollideWithAOs   bool
29676                         StepHeight       float32
29677                         FaceRotateDir    bool
29678                         FaceRotateDirOff float32 // in degrees.
29679                         BackfaceCull     bool
29680                         Nametag          string
29681                         NametagColor     color.NRGBA
29682                         FaceRotateSpeed  float32 // in degrees per second.
29683                         Infotext         string
29684                         Itemstring       string
29685                         Glow             int8
29686                         MaxBreath        uint16  // Player only.
29687                         EyeHeight        float32 // Player only.
29688                         ZoomFOV          float32 // in degrees. Player only.
29689                         UseTextureAlpha  bool
29690                         DmgTextureMod    Texture // suffix
29691                         Shaded           bool
29692                         ShowOnMinimap    bool
29693                         NametagBG        color.NRGBA
29694                 }))(obj)).MakeFootstepSnds
29695                 switch n := read8(r); n {
29696                 case 0:
29697                         *p = false
29698                 case 1:
29699                         *p = true
29700                 default:
29701                         chk(fmt.Errorf("invalid bool: %d", n))
29702                 }
29703         }
29704         {
29705                 p := &(*(*(struct {
29706                         MaxHP            uint16 // Player only.
29707                         CollideWithNodes bool
29708                         Weight           float32 // deprecated
29709                         ColBox, SelBox   Box
29710                         Pointable        bool
29711                         Visual           string
29712                         VisualSize       [3]float32
29713                         Textures         []Texture
29714                         SpriteSheetSize  [2]int16 // in sprites.
29715                         SpritePos        [2]int16 // in sprite sheet.
29716                         Visible          bool
29717                         MakeFootstepSnds bool
29718                         RotateSpeed      float32 // in radians per second.
29719                         Mesh             string
29720                         Colors           []color.NRGBA
29721                         CollideWithAOs   bool
29722                         StepHeight       float32
29723                         FaceRotateDir    bool
29724                         FaceRotateDirOff float32 // in degrees.
29725                         BackfaceCull     bool
29726                         Nametag          string
29727                         NametagColor     color.NRGBA
29728                         FaceRotateSpeed  float32 // in degrees per second.
29729                         Infotext         string
29730                         Itemstring       string
29731                         Glow             int8
29732                         MaxBreath        uint16  // Player only.
29733                         EyeHeight        float32 // Player only.
29734                         ZoomFOV          float32 // in degrees. Player only.
29735                         UseTextureAlpha  bool
29736                         DmgTextureMod    Texture // suffix
29737                         Shaded           bool
29738                         ShowOnMinimap    bool
29739                         NametagBG        color.NRGBA
29740                 }))(obj)).RotateSpeed
29741                 *p = math.Float32frombits(read32(r))
29742         }
29743         var local348 []uint8
29744         var local349 uint16
29745         {
29746                 p := &local349
29747                 *p = read16(r)
29748         }
29749         (local348) = make([]uint8, local349)
29750         {
29751                 _, err := io.ReadFull(r, (local348)[:])
29752                 chk(err)
29753         }
29754         ((*(*(struct {
29755                 MaxHP            uint16 // Player only.
29756                 CollideWithNodes bool
29757                 Weight           float32 // deprecated
29758                 ColBox, SelBox   Box
29759                 Pointable        bool
29760                 Visual           string
29761                 VisualSize       [3]float32
29762                 Textures         []Texture
29763                 SpriteSheetSize  [2]int16 // in sprites.
29764                 SpritePos        [2]int16 // in sprite sheet.
29765                 Visible          bool
29766                 MakeFootstepSnds bool
29767                 RotateSpeed      float32 // in radians per second.
29768                 Mesh             string
29769                 Colors           []color.NRGBA
29770                 CollideWithAOs   bool
29771                 StepHeight       float32
29772                 FaceRotateDir    bool
29773                 FaceRotateDirOff float32 // in degrees.
29774                 BackfaceCull     bool
29775                 Nametag          string
29776                 NametagColor     color.NRGBA
29777                 FaceRotateSpeed  float32 // in degrees per second.
29778                 Infotext         string
29779                 Itemstring       string
29780                 Glow             int8
29781                 MaxBreath        uint16  // Player only.
29782                 EyeHeight        float32 // Player only.
29783                 ZoomFOV          float32 // in degrees. Player only.
29784                 UseTextureAlpha  bool
29785                 DmgTextureMod    Texture // suffix
29786                 Shaded           bool
29787                 ShowOnMinimap    bool
29788                 NametagBG        color.NRGBA
29789         }))(obj)).Mesh) = string(local348)
29790         var local350 uint16
29791         {
29792                 p := &local350
29793                 *p = read16(r)
29794         }
29795         ((*(*(struct {
29796                 MaxHP            uint16 // Player only.
29797                 CollideWithNodes bool
29798                 Weight           float32 // deprecated
29799                 ColBox, SelBox   Box
29800                 Pointable        bool
29801                 Visual           string
29802                 VisualSize       [3]float32
29803                 Textures         []Texture
29804                 SpriteSheetSize  [2]int16 // in sprites.
29805                 SpritePos        [2]int16 // in sprite sheet.
29806                 Visible          bool
29807                 MakeFootstepSnds bool
29808                 RotateSpeed      float32 // in radians per second.
29809                 Mesh             string
29810                 Colors           []color.NRGBA
29811                 CollideWithAOs   bool
29812                 StepHeight       float32
29813                 FaceRotateDir    bool
29814                 FaceRotateDirOff float32 // in degrees.
29815                 BackfaceCull     bool
29816                 Nametag          string
29817                 NametagColor     color.NRGBA
29818                 FaceRotateSpeed  float32 // in degrees per second.
29819                 Infotext         string
29820                 Itemstring       string
29821                 Glow             int8
29822                 MaxBreath        uint16  // Player only.
29823                 EyeHeight        float32 // Player only.
29824                 ZoomFOV          float32 // in degrees. Player only.
29825                 UseTextureAlpha  bool
29826                 DmgTextureMod    Texture // suffix
29827                 Shaded           bool
29828                 ShowOnMinimap    bool
29829                 NametagBG        color.NRGBA
29830         }))(obj)).Colors) = make([]color.NRGBA, local350)
29831         for local351 := range (*(*(struct {
29832                 MaxHP            uint16 // Player only.
29833                 CollideWithNodes bool
29834                 Weight           float32 // deprecated
29835                 ColBox, SelBox   Box
29836                 Pointable        bool
29837                 Visual           string
29838                 VisualSize       [3]float32
29839                 Textures         []Texture
29840                 SpriteSheetSize  [2]int16 // in sprites.
29841                 SpritePos        [2]int16 // in sprite sheet.
29842                 Visible          bool
29843                 MakeFootstepSnds bool
29844                 RotateSpeed      float32 // in radians per second.
29845                 Mesh             string
29846                 Colors           []color.NRGBA
29847                 CollideWithAOs   bool
29848                 StepHeight       float32
29849                 FaceRotateDir    bool
29850                 FaceRotateDirOff float32 // in degrees.
29851                 BackfaceCull     bool
29852                 Nametag          string
29853                 NametagColor     color.NRGBA
29854                 FaceRotateSpeed  float32 // in degrees per second.
29855                 Infotext         string
29856                 Itemstring       string
29857                 Glow             int8
29858                 MaxBreath        uint16  // Player only.
29859                 EyeHeight        float32 // Player only.
29860                 ZoomFOV          float32 // in degrees. Player only.
29861                 UseTextureAlpha  bool
29862                 DmgTextureMod    Texture // suffix
29863                 Shaded           bool
29864                 ShowOnMinimap    bool
29865                 NametagBG        color.NRGBA
29866         }))(obj)).Colors {
29867                 {
29868                         p := &((*(*(struct {
29869                                 MaxHP            uint16 // Player only.
29870                                 CollideWithNodes bool
29871                                 Weight           float32 // deprecated
29872                                 ColBox, SelBox   Box
29873                                 Pointable        bool
29874                                 Visual           string
29875                                 VisualSize       [3]float32
29876                                 Textures         []Texture
29877                                 SpriteSheetSize  [2]int16 // in sprites.
29878                                 SpritePos        [2]int16 // in sprite sheet.
29879                                 Visible          bool
29880                                 MakeFootstepSnds bool
29881                                 RotateSpeed      float32 // in radians per second.
29882                                 Mesh             string
29883                                 Colors           []color.NRGBA
29884                                 CollideWithAOs   bool
29885                                 StepHeight       float32
29886                                 FaceRotateDir    bool
29887                                 FaceRotateDirOff float32 // in degrees.
29888                                 BackfaceCull     bool
29889                                 Nametag          string
29890                                 NametagColor     color.NRGBA
29891                                 FaceRotateSpeed  float32 // in degrees per second.
29892                                 Infotext         string
29893                                 Itemstring       string
29894                                 Glow             int8
29895                                 MaxBreath        uint16  // Player only.
29896                                 EyeHeight        float32 // Player only.
29897                                 ZoomFOV          float32 // in degrees. Player only.
29898                                 UseTextureAlpha  bool
29899                                 DmgTextureMod    Texture // suffix
29900                                 Shaded           bool
29901                                 ShowOnMinimap    bool
29902                                 NametagBG        color.NRGBA
29903                         }))(obj)).Colors)[local351]
29904                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
29905                 }
29906         }
29907         {
29908                 p := &(*(*(struct {
29909                         MaxHP            uint16 // Player only.
29910                         CollideWithNodes bool
29911                         Weight           float32 // deprecated
29912                         ColBox, SelBox   Box
29913                         Pointable        bool
29914                         Visual           string
29915                         VisualSize       [3]float32
29916                         Textures         []Texture
29917                         SpriteSheetSize  [2]int16 // in sprites.
29918                         SpritePos        [2]int16 // in sprite sheet.
29919                         Visible          bool
29920                         MakeFootstepSnds bool
29921                         RotateSpeed      float32 // in radians per second.
29922                         Mesh             string
29923                         Colors           []color.NRGBA
29924                         CollideWithAOs   bool
29925                         StepHeight       float32
29926                         FaceRotateDir    bool
29927                         FaceRotateDirOff float32 // in degrees.
29928                         BackfaceCull     bool
29929                         Nametag          string
29930                         NametagColor     color.NRGBA
29931                         FaceRotateSpeed  float32 // in degrees per second.
29932                         Infotext         string
29933                         Itemstring       string
29934                         Glow             int8
29935                         MaxBreath        uint16  // Player only.
29936                         EyeHeight        float32 // Player only.
29937                         ZoomFOV          float32 // in degrees. Player only.
29938                         UseTextureAlpha  bool
29939                         DmgTextureMod    Texture // suffix
29940                         Shaded           bool
29941                         ShowOnMinimap    bool
29942                         NametagBG        color.NRGBA
29943                 }))(obj)).CollideWithAOs
29944                 switch n := read8(r); n {
29945                 case 0:
29946                         *p = false
29947                 case 1:
29948                         *p = true
29949                 default:
29950                         chk(fmt.Errorf("invalid bool: %d", n))
29951                 }
29952         }
29953         {
29954                 p := &(*(*(struct {
29955                         MaxHP            uint16 // Player only.
29956                         CollideWithNodes bool
29957                         Weight           float32 // deprecated
29958                         ColBox, SelBox   Box
29959                         Pointable        bool
29960                         Visual           string
29961                         VisualSize       [3]float32
29962                         Textures         []Texture
29963                         SpriteSheetSize  [2]int16 // in sprites.
29964                         SpritePos        [2]int16 // in sprite sheet.
29965                         Visible          bool
29966                         MakeFootstepSnds bool
29967                         RotateSpeed      float32 // in radians per second.
29968                         Mesh             string
29969                         Colors           []color.NRGBA
29970                         CollideWithAOs   bool
29971                         StepHeight       float32
29972                         FaceRotateDir    bool
29973                         FaceRotateDirOff float32 // in degrees.
29974                         BackfaceCull     bool
29975                         Nametag          string
29976                         NametagColor     color.NRGBA
29977                         FaceRotateSpeed  float32 // in degrees per second.
29978                         Infotext         string
29979                         Itemstring       string
29980                         Glow             int8
29981                         MaxBreath        uint16  // Player only.
29982                         EyeHeight        float32 // Player only.
29983                         ZoomFOV          float32 // in degrees. Player only.
29984                         UseTextureAlpha  bool
29985                         DmgTextureMod    Texture // suffix
29986                         Shaded           bool
29987                         ShowOnMinimap    bool
29988                         NametagBG        color.NRGBA
29989                 }))(obj)).StepHeight
29990                 *p = math.Float32frombits(read32(r))
29991         }
29992         {
29993                 p := &(*(*(struct {
29994                         MaxHP            uint16 // Player only.
29995                         CollideWithNodes bool
29996                         Weight           float32 // deprecated
29997                         ColBox, SelBox   Box
29998                         Pointable        bool
29999                         Visual           string
30000                         VisualSize       [3]float32
30001                         Textures         []Texture
30002                         SpriteSheetSize  [2]int16 // in sprites.
30003                         SpritePos        [2]int16 // in sprite sheet.
30004                         Visible          bool
30005                         MakeFootstepSnds bool
30006                         RotateSpeed      float32 // in radians per second.
30007                         Mesh             string
30008                         Colors           []color.NRGBA
30009                         CollideWithAOs   bool
30010                         StepHeight       float32
30011                         FaceRotateDir    bool
30012                         FaceRotateDirOff float32 // in degrees.
30013                         BackfaceCull     bool
30014                         Nametag          string
30015                         NametagColor     color.NRGBA
30016                         FaceRotateSpeed  float32 // in degrees per second.
30017                         Infotext         string
30018                         Itemstring       string
30019                         Glow             int8
30020                         MaxBreath        uint16  // Player only.
30021                         EyeHeight        float32 // Player only.
30022                         ZoomFOV          float32 // in degrees. Player only.
30023                         UseTextureAlpha  bool
30024                         DmgTextureMod    Texture // suffix
30025                         Shaded           bool
30026                         ShowOnMinimap    bool
30027                         NametagBG        color.NRGBA
30028                 }))(obj)).FaceRotateDir
30029                 switch n := read8(r); n {
30030                 case 0:
30031                         *p = false
30032                 case 1:
30033                         *p = true
30034                 default:
30035                         chk(fmt.Errorf("invalid bool: %d", n))
30036                 }
30037         }
30038         {
30039                 p := &(*(*(struct {
30040                         MaxHP            uint16 // Player only.
30041                         CollideWithNodes bool
30042                         Weight           float32 // deprecated
30043                         ColBox, SelBox   Box
30044                         Pointable        bool
30045                         Visual           string
30046                         VisualSize       [3]float32
30047                         Textures         []Texture
30048                         SpriteSheetSize  [2]int16 // in sprites.
30049                         SpritePos        [2]int16 // in sprite sheet.
30050                         Visible          bool
30051                         MakeFootstepSnds bool
30052                         RotateSpeed      float32 // in radians per second.
30053                         Mesh             string
30054                         Colors           []color.NRGBA
30055                         CollideWithAOs   bool
30056                         StepHeight       float32
30057                         FaceRotateDir    bool
30058                         FaceRotateDirOff float32 // in degrees.
30059                         BackfaceCull     bool
30060                         Nametag          string
30061                         NametagColor     color.NRGBA
30062                         FaceRotateSpeed  float32 // in degrees per second.
30063                         Infotext         string
30064                         Itemstring       string
30065                         Glow             int8
30066                         MaxBreath        uint16  // Player only.
30067                         EyeHeight        float32 // Player only.
30068                         ZoomFOV          float32 // in degrees. Player only.
30069                         UseTextureAlpha  bool
30070                         DmgTextureMod    Texture // suffix
30071                         Shaded           bool
30072                         ShowOnMinimap    bool
30073                         NametagBG        color.NRGBA
30074                 }))(obj)).FaceRotateDirOff
30075                 *p = math.Float32frombits(read32(r))
30076         }
30077         {
30078                 p := &(*(*(struct {
30079                         MaxHP            uint16 // Player only.
30080                         CollideWithNodes bool
30081                         Weight           float32 // deprecated
30082                         ColBox, SelBox   Box
30083                         Pointable        bool
30084                         Visual           string
30085                         VisualSize       [3]float32
30086                         Textures         []Texture
30087                         SpriteSheetSize  [2]int16 // in sprites.
30088                         SpritePos        [2]int16 // in sprite sheet.
30089                         Visible          bool
30090                         MakeFootstepSnds bool
30091                         RotateSpeed      float32 // in radians per second.
30092                         Mesh             string
30093                         Colors           []color.NRGBA
30094                         CollideWithAOs   bool
30095                         StepHeight       float32
30096                         FaceRotateDir    bool
30097                         FaceRotateDirOff float32 // in degrees.
30098                         BackfaceCull     bool
30099                         Nametag          string
30100                         NametagColor     color.NRGBA
30101                         FaceRotateSpeed  float32 // in degrees per second.
30102                         Infotext         string
30103                         Itemstring       string
30104                         Glow             int8
30105                         MaxBreath        uint16  // Player only.
30106                         EyeHeight        float32 // Player only.
30107                         ZoomFOV          float32 // in degrees. Player only.
30108                         UseTextureAlpha  bool
30109                         DmgTextureMod    Texture // suffix
30110                         Shaded           bool
30111                         ShowOnMinimap    bool
30112                         NametagBG        color.NRGBA
30113                 }))(obj)).BackfaceCull
30114                 switch n := read8(r); n {
30115                 case 0:
30116                         *p = false
30117                 case 1:
30118                         *p = true
30119                 default:
30120                         chk(fmt.Errorf("invalid bool: %d", n))
30121                 }
30122         }
30123         var local352 []uint8
30124         var local353 uint16
30125         {
30126                 p := &local353
30127                 *p = read16(r)
30128         }
30129         (local352) = make([]uint8, local353)
30130         {
30131                 _, err := io.ReadFull(r, (local352)[:])
30132                 chk(err)
30133         }
30134         ((*(*(struct {
30135                 MaxHP            uint16 // Player only.
30136                 CollideWithNodes bool
30137                 Weight           float32 // deprecated
30138                 ColBox, SelBox   Box
30139                 Pointable        bool
30140                 Visual           string
30141                 VisualSize       [3]float32
30142                 Textures         []Texture
30143                 SpriteSheetSize  [2]int16 // in sprites.
30144                 SpritePos        [2]int16 // in sprite sheet.
30145                 Visible          bool
30146                 MakeFootstepSnds bool
30147                 RotateSpeed      float32 // in radians per second.
30148                 Mesh             string
30149                 Colors           []color.NRGBA
30150                 CollideWithAOs   bool
30151                 StepHeight       float32
30152                 FaceRotateDir    bool
30153                 FaceRotateDirOff float32 // in degrees.
30154                 BackfaceCull     bool
30155                 Nametag          string
30156                 NametagColor     color.NRGBA
30157                 FaceRotateSpeed  float32 // in degrees per second.
30158                 Infotext         string
30159                 Itemstring       string
30160                 Glow             int8
30161                 MaxBreath        uint16  // Player only.
30162                 EyeHeight        float32 // Player only.
30163                 ZoomFOV          float32 // in degrees. Player only.
30164                 UseTextureAlpha  bool
30165                 DmgTextureMod    Texture // suffix
30166                 Shaded           bool
30167                 ShowOnMinimap    bool
30168                 NametagBG        color.NRGBA
30169         }))(obj)).Nametag) = string(local352)
30170         {
30171                 p := &(*(*(struct {
30172                         MaxHP            uint16 // Player only.
30173                         CollideWithNodes bool
30174                         Weight           float32 // deprecated
30175                         ColBox, SelBox   Box
30176                         Pointable        bool
30177                         Visual           string
30178                         VisualSize       [3]float32
30179                         Textures         []Texture
30180                         SpriteSheetSize  [2]int16 // in sprites.
30181                         SpritePos        [2]int16 // in sprite sheet.
30182                         Visible          bool
30183                         MakeFootstepSnds bool
30184                         RotateSpeed      float32 // in radians per second.
30185                         Mesh             string
30186                         Colors           []color.NRGBA
30187                         CollideWithAOs   bool
30188                         StepHeight       float32
30189                         FaceRotateDir    bool
30190                         FaceRotateDirOff float32 // in degrees.
30191                         BackfaceCull     bool
30192                         Nametag          string
30193                         NametagColor     color.NRGBA
30194                         FaceRotateSpeed  float32 // in degrees per second.
30195                         Infotext         string
30196                         Itemstring       string
30197                         Glow             int8
30198                         MaxBreath        uint16  // Player only.
30199                         EyeHeight        float32 // Player only.
30200                         ZoomFOV          float32 // in degrees. Player only.
30201                         UseTextureAlpha  bool
30202                         DmgTextureMod    Texture // suffix
30203                         Shaded           bool
30204                         ShowOnMinimap    bool
30205                         NametagBG        color.NRGBA
30206                 }))(obj)).NametagColor
30207                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30208         }
30209         {
30210                 p := &(*(*(struct {
30211                         MaxHP            uint16 // Player only.
30212                         CollideWithNodes bool
30213                         Weight           float32 // deprecated
30214                         ColBox, SelBox   Box
30215                         Pointable        bool
30216                         Visual           string
30217                         VisualSize       [3]float32
30218                         Textures         []Texture
30219                         SpriteSheetSize  [2]int16 // in sprites.
30220                         SpritePos        [2]int16 // in sprite sheet.
30221                         Visible          bool
30222                         MakeFootstepSnds bool
30223                         RotateSpeed      float32 // in radians per second.
30224                         Mesh             string
30225                         Colors           []color.NRGBA
30226                         CollideWithAOs   bool
30227                         StepHeight       float32
30228                         FaceRotateDir    bool
30229                         FaceRotateDirOff float32 // in degrees.
30230                         BackfaceCull     bool
30231                         Nametag          string
30232                         NametagColor     color.NRGBA
30233                         FaceRotateSpeed  float32 // in degrees per second.
30234                         Infotext         string
30235                         Itemstring       string
30236                         Glow             int8
30237                         MaxBreath        uint16  // Player only.
30238                         EyeHeight        float32 // Player only.
30239                         ZoomFOV          float32 // in degrees. Player only.
30240                         UseTextureAlpha  bool
30241                         DmgTextureMod    Texture // suffix
30242                         Shaded           bool
30243                         ShowOnMinimap    bool
30244                         NametagBG        color.NRGBA
30245                 }))(obj)).FaceRotateSpeed
30246                 *p = math.Float32frombits(read32(r))
30247         }
30248         var local354 []uint8
30249         var local355 uint16
30250         {
30251                 p := &local355
30252                 *p = read16(r)
30253         }
30254         (local354) = make([]uint8, local355)
30255         {
30256                 _, err := io.ReadFull(r, (local354)[:])
30257                 chk(err)
30258         }
30259         ((*(*(struct {
30260                 MaxHP            uint16 // Player only.
30261                 CollideWithNodes bool
30262                 Weight           float32 // deprecated
30263                 ColBox, SelBox   Box
30264                 Pointable        bool
30265                 Visual           string
30266                 VisualSize       [3]float32
30267                 Textures         []Texture
30268                 SpriteSheetSize  [2]int16 // in sprites.
30269                 SpritePos        [2]int16 // in sprite sheet.
30270                 Visible          bool
30271                 MakeFootstepSnds bool
30272                 RotateSpeed      float32 // in radians per second.
30273                 Mesh             string
30274                 Colors           []color.NRGBA
30275                 CollideWithAOs   bool
30276                 StepHeight       float32
30277                 FaceRotateDir    bool
30278                 FaceRotateDirOff float32 // in degrees.
30279                 BackfaceCull     bool
30280                 Nametag          string
30281                 NametagColor     color.NRGBA
30282                 FaceRotateSpeed  float32 // in degrees per second.
30283                 Infotext         string
30284                 Itemstring       string
30285                 Glow             int8
30286                 MaxBreath        uint16  // Player only.
30287                 EyeHeight        float32 // Player only.
30288                 ZoomFOV          float32 // in degrees. Player only.
30289                 UseTextureAlpha  bool
30290                 DmgTextureMod    Texture // suffix
30291                 Shaded           bool
30292                 ShowOnMinimap    bool
30293                 NametagBG        color.NRGBA
30294         }))(obj)).Infotext) = string(local354)
30295         var local356 []uint8
30296         var local357 uint16
30297         {
30298                 p := &local357
30299                 *p = read16(r)
30300         }
30301         (local356) = make([]uint8, local357)
30302         {
30303                 _, err := io.ReadFull(r, (local356)[:])
30304                 chk(err)
30305         }
30306         ((*(*(struct {
30307                 MaxHP            uint16 // Player only.
30308                 CollideWithNodes bool
30309                 Weight           float32 // deprecated
30310                 ColBox, SelBox   Box
30311                 Pointable        bool
30312                 Visual           string
30313                 VisualSize       [3]float32
30314                 Textures         []Texture
30315                 SpriteSheetSize  [2]int16 // in sprites.
30316                 SpritePos        [2]int16 // in sprite sheet.
30317                 Visible          bool
30318                 MakeFootstepSnds bool
30319                 RotateSpeed      float32 // in radians per second.
30320                 Mesh             string
30321                 Colors           []color.NRGBA
30322                 CollideWithAOs   bool
30323                 StepHeight       float32
30324                 FaceRotateDir    bool
30325                 FaceRotateDirOff float32 // in degrees.
30326                 BackfaceCull     bool
30327                 Nametag          string
30328                 NametagColor     color.NRGBA
30329                 FaceRotateSpeed  float32 // in degrees per second.
30330                 Infotext         string
30331                 Itemstring       string
30332                 Glow             int8
30333                 MaxBreath        uint16  // Player only.
30334                 EyeHeight        float32 // Player only.
30335                 ZoomFOV          float32 // in degrees. Player only.
30336                 UseTextureAlpha  bool
30337                 DmgTextureMod    Texture // suffix
30338                 Shaded           bool
30339                 ShowOnMinimap    bool
30340                 NametagBG        color.NRGBA
30341         }))(obj)).Itemstring) = string(local356)
30342         {
30343                 p := &(*(*(struct {
30344                         MaxHP            uint16 // Player only.
30345                         CollideWithNodes bool
30346                         Weight           float32 // deprecated
30347                         ColBox, SelBox   Box
30348                         Pointable        bool
30349                         Visual           string
30350                         VisualSize       [3]float32
30351                         Textures         []Texture
30352                         SpriteSheetSize  [2]int16 // in sprites.
30353                         SpritePos        [2]int16 // in sprite sheet.
30354                         Visible          bool
30355                         MakeFootstepSnds bool
30356                         RotateSpeed      float32 // in radians per second.
30357                         Mesh             string
30358                         Colors           []color.NRGBA
30359                         CollideWithAOs   bool
30360                         StepHeight       float32
30361                         FaceRotateDir    bool
30362                         FaceRotateDirOff float32 // in degrees.
30363                         BackfaceCull     bool
30364                         Nametag          string
30365                         NametagColor     color.NRGBA
30366                         FaceRotateSpeed  float32 // in degrees per second.
30367                         Infotext         string
30368                         Itemstring       string
30369                         Glow             int8
30370                         MaxBreath        uint16  // Player only.
30371                         EyeHeight        float32 // Player only.
30372                         ZoomFOV          float32 // in degrees. Player only.
30373                         UseTextureAlpha  bool
30374                         DmgTextureMod    Texture // suffix
30375                         Shaded           bool
30376                         ShowOnMinimap    bool
30377                         NametagBG        color.NRGBA
30378                 }))(obj)).Glow
30379                 *p = int8(read8(r))
30380         }
30381         {
30382                 p := &(*(*(struct {
30383                         MaxHP            uint16 // Player only.
30384                         CollideWithNodes bool
30385                         Weight           float32 // deprecated
30386                         ColBox, SelBox   Box
30387                         Pointable        bool
30388                         Visual           string
30389                         VisualSize       [3]float32
30390                         Textures         []Texture
30391                         SpriteSheetSize  [2]int16 // in sprites.
30392                         SpritePos        [2]int16 // in sprite sheet.
30393                         Visible          bool
30394                         MakeFootstepSnds bool
30395                         RotateSpeed      float32 // in radians per second.
30396                         Mesh             string
30397                         Colors           []color.NRGBA
30398                         CollideWithAOs   bool
30399                         StepHeight       float32
30400                         FaceRotateDir    bool
30401                         FaceRotateDirOff float32 // in degrees.
30402                         BackfaceCull     bool
30403                         Nametag          string
30404                         NametagColor     color.NRGBA
30405                         FaceRotateSpeed  float32 // in degrees per second.
30406                         Infotext         string
30407                         Itemstring       string
30408                         Glow             int8
30409                         MaxBreath        uint16  // Player only.
30410                         EyeHeight        float32 // Player only.
30411                         ZoomFOV          float32 // in degrees. Player only.
30412                         UseTextureAlpha  bool
30413                         DmgTextureMod    Texture // suffix
30414                         Shaded           bool
30415                         ShowOnMinimap    bool
30416                         NametagBG        color.NRGBA
30417                 }))(obj)).MaxBreath
30418                 *p = read16(r)
30419         }
30420         {
30421                 p := &(*(*(struct {
30422                         MaxHP            uint16 // Player only.
30423                         CollideWithNodes bool
30424                         Weight           float32 // deprecated
30425                         ColBox, SelBox   Box
30426                         Pointable        bool
30427                         Visual           string
30428                         VisualSize       [3]float32
30429                         Textures         []Texture
30430                         SpriteSheetSize  [2]int16 // in sprites.
30431                         SpritePos        [2]int16 // in sprite sheet.
30432                         Visible          bool
30433                         MakeFootstepSnds bool
30434                         RotateSpeed      float32 // in radians per second.
30435                         Mesh             string
30436                         Colors           []color.NRGBA
30437                         CollideWithAOs   bool
30438                         StepHeight       float32
30439                         FaceRotateDir    bool
30440                         FaceRotateDirOff float32 // in degrees.
30441                         BackfaceCull     bool
30442                         Nametag          string
30443                         NametagColor     color.NRGBA
30444                         FaceRotateSpeed  float32 // in degrees per second.
30445                         Infotext         string
30446                         Itemstring       string
30447                         Glow             int8
30448                         MaxBreath        uint16  // Player only.
30449                         EyeHeight        float32 // Player only.
30450                         ZoomFOV          float32 // in degrees. Player only.
30451                         UseTextureAlpha  bool
30452                         DmgTextureMod    Texture // suffix
30453                         Shaded           bool
30454                         ShowOnMinimap    bool
30455                         NametagBG        color.NRGBA
30456                 }))(obj)).EyeHeight
30457                 *p = math.Float32frombits(read32(r))
30458         }
30459         {
30460                 p := &(*(*(struct {
30461                         MaxHP            uint16 // Player only.
30462                         CollideWithNodes bool
30463                         Weight           float32 // deprecated
30464                         ColBox, SelBox   Box
30465                         Pointable        bool
30466                         Visual           string
30467                         VisualSize       [3]float32
30468                         Textures         []Texture
30469                         SpriteSheetSize  [2]int16 // in sprites.
30470                         SpritePos        [2]int16 // in sprite sheet.
30471                         Visible          bool
30472                         MakeFootstepSnds bool
30473                         RotateSpeed      float32 // in radians per second.
30474                         Mesh             string
30475                         Colors           []color.NRGBA
30476                         CollideWithAOs   bool
30477                         StepHeight       float32
30478                         FaceRotateDir    bool
30479                         FaceRotateDirOff float32 // in degrees.
30480                         BackfaceCull     bool
30481                         Nametag          string
30482                         NametagColor     color.NRGBA
30483                         FaceRotateSpeed  float32 // in degrees per second.
30484                         Infotext         string
30485                         Itemstring       string
30486                         Glow             int8
30487                         MaxBreath        uint16  // Player only.
30488                         EyeHeight        float32 // Player only.
30489                         ZoomFOV          float32 // in degrees. Player only.
30490                         UseTextureAlpha  bool
30491                         DmgTextureMod    Texture // suffix
30492                         Shaded           bool
30493                         ShowOnMinimap    bool
30494                         NametagBG        color.NRGBA
30495                 }))(obj)).ZoomFOV
30496                 *p = math.Float32frombits(read32(r))
30497         }
30498         {
30499                 p := &(*(*(struct {
30500                         MaxHP            uint16 // Player only.
30501                         CollideWithNodes bool
30502                         Weight           float32 // deprecated
30503                         ColBox, SelBox   Box
30504                         Pointable        bool
30505                         Visual           string
30506                         VisualSize       [3]float32
30507                         Textures         []Texture
30508                         SpriteSheetSize  [2]int16 // in sprites.
30509                         SpritePos        [2]int16 // in sprite sheet.
30510                         Visible          bool
30511                         MakeFootstepSnds bool
30512                         RotateSpeed      float32 // in radians per second.
30513                         Mesh             string
30514                         Colors           []color.NRGBA
30515                         CollideWithAOs   bool
30516                         StepHeight       float32
30517                         FaceRotateDir    bool
30518                         FaceRotateDirOff float32 // in degrees.
30519                         BackfaceCull     bool
30520                         Nametag          string
30521                         NametagColor     color.NRGBA
30522                         FaceRotateSpeed  float32 // in degrees per second.
30523                         Infotext         string
30524                         Itemstring       string
30525                         Glow             int8
30526                         MaxBreath        uint16  // Player only.
30527                         EyeHeight        float32 // Player only.
30528                         ZoomFOV          float32 // in degrees. Player only.
30529                         UseTextureAlpha  bool
30530                         DmgTextureMod    Texture // suffix
30531                         Shaded           bool
30532                         ShowOnMinimap    bool
30533                         NametagBG        color.NRGBA
30534                 }))(obj)).UseTextureAlpha
30535                 switch n := read8(r); n {
30536                 case 0:
30537                         *p = false
30538                 case 1:
30539                         *p = true
30540                 default:
30541                         chk(fmt.Errorf("invalid bool: %d", n))
30542                 }
30543         }
30544         if err := pcall(func() {
30545                 ((*(*(struct {
30546                         MaxHP            uint16 // Player only.
30547                         CollideWithNodes bool
30548                         Weight           float32 // deprecated
30549                         ColBox, SelBox   Box
30550                         Pointable        bool
30551                         Visual           string
30552                         VisualSize       [3]float32
30553                         Textures         []Texture
30554                         SpriteSheetSize  [2]int16 // in sprites.
30555                         SpritePos        [2]int16 // in sprite sheet.
30556                         Visible          bool
30557                         MakeFootstepSnds bool
30558                         RotateSpeed      float32 // in radians per second.
30559                         Mesh             string
30560                         Colors           []color.NRGBA
30561                         CollideWithAOs   bool
30562                         StepHeight       float32
30563                         FaceRotateDir    bool
30564                         FaceRotateDirOff float32 // in degrees.
30565                         BackfaceCull     bool
30566                         Nametag          string
30567                         NametagColor     color.NRGBA
30568                         FaceRotateSpeed  float32 // in degrees per second.
30569                         Infotext         string
30570                         Itemstring       string
30571                         Glow             int8
30572                         MaxBreath        uint16  // Player only.
30573                         EyeHeight        float32 // Player only.
30574                         ZoomFOV          float32 // in degrees. Player only.
30575                         UseTextureAlpha  bool
30576                         DmgTextureMod    Texture // suffix
30577                         Shaded           bool
30578                         ShowOnMinimap    bool
30579                         NametagBG        color.NRGBA
30580                 }))(obj)).DmgTextureMod).deserialize(r)
30581         }); err != nil {
30582                 if err == io.EOF {
30583                         chk(io.EOF)
30584                 }
30585                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
30586         }
30587         {
30588                 p := &(*(*(struct {
30589                         MaxHP            uint16 // Player only.
30590                         CollideWithNodes bool
30591                         Weight           float32 // deprecated
30592                         ColBox, SelBox   Box
30593                         Pointable        bool
30594                         Visual           string
30595                         VisualSize       [3]float32
30596                         Textures         []Texture
30597                         SpriteSheetSize  [2]int16 // in sprites.
30598                         SpritePos        [2]int16 // in sprite sheet.
30599                         Visible          bool
30600                         MakeFootstepSnds bool
30601                         RotateSpeed      float32 // in radians per second.
30602                         Mesh             string
30603                         Colors           []color.NRGBA
30604                         CollideWithAOs   bool
30605                         StepHeight       float32
30606                         FaceRotateDir    bool
30607                         FaceRotateDirOff float32 // in degrees.
30608                         BackfaceCull     bool
30609                         Nametag          string
30610                         NametagColor     color.NRGBA
30611                         FaceRotateSpeed  float32 // in degrees per second.
30612                         Infotext         string
30613                         Itemstring       string
30614                         Glow             int8
30615                         MaxBreath        uint16  // Player only.
30616                         EyeHeight        float32 // Player only.
30617                         ZoomFOV          float32 // in degrees. Player only.
30618                         UseTextureAlpha  bool
30619                         DmgTextureMod    Texture // suffix
30620                         Shaded           bool
30621                         ShowOnMinimap    bool
30622                         NametagBG        color.NRGBA
30623                 }))(obj)).Shaded
30624                 switch n := read8(r); n {
30625                 case 0:
30626                         *p = false
30627                 case 1:
30628                         *p = true
30629                 default:
30630                         chk(fmt.Errorf("invalid bool: %d", n))
30631                 }
30632         }
30633         {
30634                 p := &(*(*(struct {
30635                         MaxHP            uint16 // Player only.
30636                         CollideWithNodes bool
30637                         Weight           float32 // deprecated
30638                         ColBox, SelBox   Box
30639                         Pointable        bool
30640                         Visual           string
30641                         VisualSize       [3]float32
30642                         Textures         []Texture
30643                         SpriteSheetSize  [2]int16 // in sprites.
30644                         SpritePos        [2]int16 // in sprite sheet.
30645                         Visible          bool
30646                         MakeFootstepSnds bool
30647                         RotateSpeed      float32 // in radians per second.
30648                         Mesh             string
30649                         Colors           []color.NRGBA
30650                         CollideWithAOs   bool
30651                         StepHeight       float32
30652                         FaceRotateDir    bool
30653                         FaceRotateDirOff float32 // in degrees.
30654                         BackfaceCull     bool
30655                         Nametag          string
30656                         NametagColor     color.NRGBA
30657                         FaceRotateSpeed  float32 // in degrees per second.
30658                         Infotext         string
30659                         Itemstring       string
30660                         Glow             int8
30661                         MaxBreath        uint16  // Player only.
30662                         EyeHeight        float32 // Player only.
30663                         ZoomFOV          float32 // in degrees. Player only.
30664                         UseTextureAlpha  bool
30665                         DmgTextureMod    Texture // suffix
30666                         Shaded           bool
30667                         ShowOnMinimap    bool
30668                         NametagBG        color.NRGBA
30669                 }))(obj)).ShowOnMinimap
30670                 switch n := read8(r); n {
30671                 case 0:
30672                         *p = false
30673                 case 1:
30674                         *p = true
30675                 default:
30676                         chk(fmt.Errorf("invalid bool: %d", n))
30677                 }
30678         }
30679         {
30680                 p := &(*(*(struct {
30681                         MaxHP            uint16 // Player only.
30682                         CollideWithNodes bool
30683                         Weight           float32 // deprecated
30684                         ColBox, SelBox   Box
30685                         Pointable        bool
30686                         Visual           string
30687                         VisualSize       [3]float32
30688                         Textures         []Texture
30689                         SpriteSheetSize  [2]int16 // in sprites.
30690                         SpritePos        [2]int16 // in sprite sheet.
30691                         Visible          bool
30692                         MakeFootstepSnds bool
30693                         RotateSpeed      float32 // in radians per second.
30694                         Mesh             string
30695                         Colors           []color.NRGBA
30696                         CollideWithAOs   bool
30697                         StepHeight       float32
30698                         FaceRotateDir    bool
30699                         FaceRotateDirOff float32 // in degrees.
30700                         BackfaceCull     bool
30701                         Nametag          string
30702                         NametagColor     color.NRGBA
30703                         FaceRotateSpeed  float32 // in degrees per second.
30704                         Infotext         string
30705                         Itemstring       string
30706                         Glow             int8
30707                         MaxBreath        uint16  // Player only.
30708                         EyeHeight        float32 // Player only.
30709                         ZoomFOV          float32 // in degrees. Player only.
30710                         UseTextureAlpha  bool
30711                         DmgTextureMod    Texture // suffix
30712                         Shaded           bool
30713                         ShowOnMinimap    bool
30714                         NametagBG        color.NRGBA
30715                 }))(obj)).NametagBG
30716                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30717         }
30718 }
30719
30720 func (obj *AOPos) serialize(w io.Writer) {
30721         if err := pcall(func() {
30722                 ((*(*(struct {
30723                         Pos
30724                         Vel, Acc Vec
30725                         Rot      [3]float32
30726
30727                         Interpolate    bool
30728                         End            bool
30729                         UpdateInterval float32
30730                 }))(obj)).Pos).serialize(w)
30731         }); err != nil {
30732                 if err == io.EOF {
30733                         chk(io.EOF)
30734                 }
30735                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
30736         }
30737         if err := pcall(func() {
30738                 ((*(*(struct {
30739                         Pos
30740                         Vel, Acc Vec
30741                         Rot      [3]float32
30742
30743                         Interpolate    bool
30744                         End            bool
30745                         UpdateInterval float32
30746                 }))(obj)).Vel).serialize(w)
30747         }); err != nil {
30748                 if err == io.EOF {
30749                         chk(io.EOF)
30750                 }
30751                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
30752         }
30753         if err := pcall(func() {
30754                 ((*(*(struct {
30755                         Pos
30756                         Vel, Acc Vec
30757                         Rot      [3]float32
30758
30759                         Interpolate    bool
30760                         End            bool
30761                         UpdateInterval float32
30762                 }))(obj)).Acc).serialize(w)
30763         }); err != nil {
30764                 if err == io.EOF {
30765                         chk(io.EOF)
30766                 }
30767                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
30768         }
30769         for local358 := range (*(*(struct {
30770                 Pos
30771                 Vel, Acc Vec
30772                 Rot      [3]float32
30773
30774                 Interpolate    bool
30775                 End            bool
30776                 UpdateInterval float32
30777         }))(obj)).Rot {
30778                 {
30779                         x := ((*(*(struct {
30780                                 Pos
30781                                 Vel, Acc Vec
30782                                 Rot      [3]float32
30783
30784                                 Interpolate    bool
30785                                 End            bool
30786                                 UpdateInterval float32
30787                         }))(obj)).Rot)[local358]
30788                         write32(w, math.Float32bits(x))
30789                 }
30790         }
30791         {
30792                 x := (*(*(struct {
30793                         Pos
30794                         Vel, Acc Vec
30795                         Rot      [3]float32
30796
30797                         Interpolate    bool
30798                         End            bool
30799                         UpdateInterval float32
30800                 }))(obj)).Interpolate
30801                 if x {
30802                         write8(w, 1)
30803                 } else {
30804                         write8(w, 0)
30805                 }
30806         }
30807         {
30808                 x := (*(*(struct {
30809                         Pos
30810                         Vel, Acc Vec
30811                         Rot      [3]float32
30812
30813                         Interpolate    bool
30814                         End            bool
30815                         UpdateInterval float32
30816                 }))(obj)).End
30817                 if x {
30818                         write8(w, 1)
30819                 } else {
30820                         write8(w, 0)
30821                 }
30822         }
30823         {
30824                 x := (*(*(struct {
30825                         Pos
30826                         Vel, Acc Vec
30827                         Rot      [3]float32
30828
30829                         Interpolate    bool
30830                         End            bool
30831                         UpdateInterval float32
30832                 }))(obj)).UpdateInterval
30833                 write32(w, math.Float32bits(x))
30834         }
30835 }
30836
30837 func (obj *AOPos) deserialize(r io.Reader) {
30838         if err := pcall(func() {
30839                 ((*(*(struct {
30840                         Pos
30841                         Vel, Acc Vec
30842                         Rot      [3]float32
30843
30844                         Interpolate    bool
30845                         End            bool
30846                         UpdateInterval float32
30847                 }))(obj)).Pos).deserialize(r)
30848         }); err != nil {
30849                 if err == io.EOF {
30850                         chk(io.EOF)
30851                 }
30852                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
30853         }
30854         if err := pcall(func() {
30855                 ((*(*(struct {
30856                         Pos
30857                         Vel, Acc Vec
30858                         Rot      [3]float32
30859
30860                         Interpolate    bool
30861                         End            bool
30862                         UpdateInterval float32
30863                 }))(obj)).Vel).deserialize(r)
30864         }); err != nil {
30865                 if err == io.EOF {
30866                         chk(io.EOF)
30867                 }
30868                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
30869         }
30870         if err := pcall(func() {
30871                 ((*(*(struct {
30872                         Pos
30873                         Vel, Acc Vec
30874                         Rot      [3]float32
30875
30876                         Interpolate    bool
30877                         End            bool
30878                         UpdateInterval float32
30879                 }))(obj)).Acc).deserialize(r)
30880         }); err != nil {
30881                 if err == io.EOF {
30882                         chk(io.EOF)
30883                 }
30884                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
30885         }
30886         for local359 := range (*(*(struct {
30887                 Pos
30888                 Vel, Acc Vec
30889                 Rot      [3]float32
30890
30891                 Interpolate    bool
30892                 End            bool
30893                 UpdateInterval float32
30894         }))(obj)).Rot {
30895                 {
30896                         p := &((*(*(struct {
30897                                 Pos
30898                                 Vel, Acc Vec
30899                                 Rot      [3]float32
30900
30901                                 Interpolate    bool
30902                                 End            bool
30903                                 UpdateInterval float32
30904                         }))(obj)).Rot)[local359]
30905                         *p = math.Float32frombits(read32(r))
30906                 }
30907         }
30908         {
30909                 p := &(*(*(struct {
30910                         Pos
30911                         Vel, Acc Vec
30912                         Rot      [3]float32
30913
30914                         Interpolate    bool
30915                         End            bool
30916                         UpdateInterval float32
30917                 }))(obj)).Interpolate
30918                 switch n := read8(r); n {
30919                 case 0:
30920                         *p = false
30921                 case 1:
30922                         *p = true
30923                 default:
30924                         chk(fmt.Errorf("invalid bool: %d", n))
30925                 }
30926         }
30927         {
30928                 p := &(*(*(struct {
30929                         Pos
30930                         Vel, Acc Vec
30931                         Rot      [3]float32
30932
30933                         Interpolate    bool
30934                         End            bool
30935                         UpdateInterval float32
30936                 }))(obj)).End
30937                 switch n := read8(r); n {
30938                 case 0:
30939                         *p = false
30940                 case 1:
30941                         *p = true
30942                 default:
30943                         chk(fmt.Errorf("invalid bool: %d", n))
30944                 }
30945         }
30946         {
30947                 p := &(*(*(struct {
30948                         Pos
30949                         Vel, Acc Vec
30950                         Rot      [3]float32
30951
30952                         Interpolate    bool
30953                         End            bool
30954                         UpdateInterval float32
30955                 }))(obj)).UpdateInterval
30956                 *p = math.Float32frombits(read32(r))
30957         }
30958 }
30959
30960 func (obj *AOSprite) serialize(w io.Writer) {
30961         for local360 := range (*(*(struct {
30962                 Frame0          [2]int16
30963                 Frames          uint16
30964                 FrameDuration   float32
30965                 ViewAngleFrames bool
30966         }))(obj)).Frame0 {
30967                 {
30968                         x := ((*(*(struct {
30969                                 Frame0          [2]int16
30970                                 Frames          uint16
30971                                 FrameDuration   float32
30972                                 ViewAngleFrames bool
30973                         }))(obj)).Frame0)[local360]
30974                         write16(w, uint16(x))
30975                 }
30976         }
30977         {
30978                 x := (*(*(struct {
30979                         Frame0          [2]int16
30980                         Frames          uint16
30981                         FrameDuration   float32
30982                         ViewAngleFrames bool
30983                 }))(obj)).Frames
30984                 write16(w, uint16(x))
30985         }
30986         {
30987                 x := (*(*(struct {
30988                         Frame0          [2]int16
30989                         Frames          uint16
30990                         FrameDuration   float32
30991                         ViewAngleFrames bool
30992                 }))(obj)).FrameDuration
30993                 write32(w, math.Float32bits(x))
30994         }
30995         {
30996                 x := (*(*(struct {
30997                         Frame0          [2]int16
30998                         Frames          uint16
30999                         FrameDuration   float32
31000                         ViewAngleFrames bool
31001                 }))(obj)).ViewAngleFrames
31002                 if x {
31003                         write8(w, 1)
31004                 } else {
31005                         write8(w, 0)
31006                 }
31007         }
31008 }
31009
31010 func (obj *AOSprite) deserialize(r io.Reader) {
31011         for local361 := range (*(*(struct {
31012                 Frame0          [2]int16
31013                 Frames          uint16
31014                 FrameDuration   float32
31015                 ViewAngleFrames bool
31016         }))(obj)).Frame0 {
31017                 {
31018                         p := &((*(*(struct {
31019                                 Frame0          [2]int16
31020                                 Frames          uint16
31021                                 FrameDuration   float32
31022                                 ViewAngleFrames bool
31023                         }))(obj)).Frame0)[local361]
31024                         *p = int16(read16(r))
31025                 }
31026         }
31027         {
31028                 p := &(*(*(struct {
31029                         Frame0          [2]int16
31030                         Frames          uint16
31031                         FrameDuration   float32
31032                         ViewAngleFrames bool
31033                 }))(obj)).Frames
31034                 *p = read16(r)
31035         }
31036         {
31037                 p := &(*(*(struct {
31038                         Frame0          [2]int16
31039                         Frames          uint16
31040                         FrameDuration   float32
31041                         ViewAngleFrames bool
31042                 }))(obj)).FrameDuration
31043                 *p = math.Float32frombits(read32(r))
31044         }
31045         {
31046                 p := &(*(*(struct {
31047                         Frame0          [2]int16
31048                         Frames          uint16
31049                         FrameDuration   float32
31050                         ViewAngleFrames bool
31051                 }))(obj)).ViewAngleFrames
31052                 switch n := read8(r); n {
31053                 case 0:
31054                         *p = false
31055                 case 1:
31056                         *p = true
31057                 default:
31058                         chk(fmt.Errorf("invalid bool: %d", n))
31059                 }
31060         }
31061 }
31062
31063 func (obj *Group) serialize(w io.Writer) {
31064         if len(([]byte((*(*(struct {
31065                 Name   string
31066                 Rating int16
31067         }))(obj)).Name))) > math.MaxUint16 {
31068                 chk(ErrTooLong)
31069         }
31070         {
31071                 x := uint16(len(([]byte((*(*(struct {
31072                         Name   string
31073                         Rating int16
31074                 }))(obj)).Name))))
31075                 write16(w, uint16(x))
31076         }
31077         {
31078                 _, err := w.Write(([]byte((*(*(struct {
31079                         Name   string
31080                         Rating int16
31081                 }))(obj)).Name))[:])
31082                 chk(err)
31083         }
31084         {
31085                 x := (*(*(struct {
31086                         Name   string
31087                         Rating int16
31088                 }))(obj)).Rating
31089                 write16(w, uint16(x))
31090         }
31091 }
31092
31093 func (obj *Group) deserialize(r io.Reader) {
31094         var local362 []uint8
31095         var local363 uint16
31096         {
31097                 p := &local363
31098                 *p = read16(r)
31099         }
31100         (local362) = make([]uint8, local363)
31101         {
31102                 _, err := io.ReadFull(r, (local362)[:])
31103                 chk(err)
31104         }
31105         ((*(*(struct {
31106                 Name   string
31107                 Rating int16
31108         }))(obj)).Name) = string(local362)
31109         {
31110                 p := &(*(*(struct {
31111                         Name   string
31112                         Rating int16
31113                 }))(obj)).Rating
31114                 *p = int16(read16(r))
31115         }
31116 }
31117
31118 func (obj *AOAnim) serialize(w io.Writer) {
31119         for local364 := range (*(*(struct {
31120                 Frames [2]int32
31121                 Speed  float32
31122                 Blend  float32
31123                 NoLoop bool
31124         }))(obj)).Frames {
31125                 {
31126                         x := ((*(*(struct {
31127                                 Frames [2]int32
31128                                 Speed  float32
31129                                 Blend  float32
31130                                 NoLoop bool
31131                         }))(obj)).Frames)[local364]
31132                         write32(w, uint32(x))
31133                 }
31134         }
31135         {
31136                 x := (*(*(struct {
31137                         Frames [2]int32
31138                         Speed  float32
31139                         Blend  float32
31140                         NoLoop bool
31141                 }))(obj)).Speed
31142                 write32(w, math.Float32bits(x))
31143         }
31144         {
31145                 x := (*(*(struct {
31146                         Frames [2]int32
31147                         Speed  float32
31148                         Blend  float32
31149                         NoLoop bool
31150                 }))(obj)).Blend
31151                 write32(w, math.Float32bits(x))
31152         }
31153         {
31154                 x := (*(*(struct {
31155                         Frames [2]int32
31156                         Speed  float32
31157                         Blend  float32
31158                         NoLoop bool
31159                 }))(obj)).NoLoop
31160                 if x {
31161                         write8(w, 1)
31162                 } else {
31163                         write8(w, 0)
31164                 }
31165         }
31166 }
31167
31168 func (obj *AOAnim) deserialize(r io.Reader) {
31169         for local365 := range (*(*(struct {
31170                 Frames [2]int32
31171                 Speed  float32
31172                 Blend  float32
31173                 NoLoop bool
31174         }))(obj)).Frames {
31175                 {
31176                         p := &((*(*(struct {
31177                                 Frames [2]int32
31178                                 Speed  float32
31179                                 Blend  float32
31180                                 NoLoop bool
31181                         }))(obj)).Frames)[local365]
31182                         *p = int32(read32(r))
31183                 }
31184         }
31185         {
31186                 p := &(*(*(struct {
31187                         Frames [2]int32
31188                         Speed  float32
31189                         Blend  float32
31190                         NoLoop bool
31191                 }))(obj)).Speed
31192                 *p = math.Float32frombits(read32(r))
31193         }
31194         {
31195                 p := &(*(*(struct {
31196                         Frames [2]int32
31197                         Speed  float32
31198                         Blend  float32
31199                         NoLoop bool
31200                 }))(obj)).Blend
31201                 *p = math.Float32frombits(read32(r))
31202         }
31203         {
31204                 p := &(*(*(struct {
31205                         Frames [2]int32
31206                         Speed  float32
31207                         Blend  float32
31208                         NoLoop bool
31209                 }))(obj)).NoLoop
31210                 switch n := read8(r); n {
31211                 case 0:
31212                         *p = false
31213                 case 1:
31214                         *p = true
31215                 default:
31216                         chk(fmt.Errorf("invalid bool: %d", n))
31217                 }
31218         }
31219 }
31220
31221 func (obj *AOBonePos) serialize(w io.Writer) {
31222         if err := pcall(func() {
31223                 ((*(*(struct {
31224                         Pos Vec
31225                         Rot [3]float32
31226                 }))(obj)).Pos).serialize(w)
31227         }); err != nil {
31228                 if err == io.EOF {
31229                         chk(io.EOF)
31230                 }
31231                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31232         }
31233         for local366 := range (*(*(struct {
31234                 Pos Vec
31235                 Rot [3]float32
31236         }))(obj)).Rot {
31237                 {
31238                         x := ((*(*(struct {
31239                                 Pos Vec
31240                                 Rot [3]float32
31241                         }))(obj)).Rot)[local366]
31242                         write32(w, math.Float32bits(x))
31243                 }
31244         }
31245 }
31246
31247 func (obj *AOBonePos) deserialize(r io.Reader) {
31248         if err := pcall(func() {
31249                 ((*(*(struct {
31250                         Pos Vec
31251                         Rot [3]float32
31252                 }))(obj)).Pos).deserialize(r)
31253         }); err != nil {
31254                 if err == io.EOF {
31255                         chk(io.EOF)
31256                 }
31257                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31258         }
31259         for local367 := range (*(*(struct {
31260                 Pos Vec
31261                 Rot [3]float32
31262         }))(obj)).Rot {
31263                 {
31264                         p := &((*(*(struct {
31265                                 Pos Vec
31266                                 Rot [3]float32
31267                         }))(obj)).Rot)[local367]
31268                         *p = math.Float32frombits(read32(r))
31269                 }
31270         }
31271 }
31272
31273 func (obj *AOAttach) serialize(w io.Writer) {
31274         if err := pcall(func() {
31275                 ((*(*(struct {
31276                         ParentID     AOID
31277                         Bone         string
31278                         Pos          Vec
31279                         Rot          [3]float32
31280                         ForceVisible bool
31281                 }))(obj)).ParentID).serialize(w)
31282         }); err != nil {
31283                 if err == io.EOF {
31284                         chk(io.EOF)
31285                 }
31286                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
31287         }
31288         if len(([]byte((*(*(struct {
31289                 ParentID     AOID
31290                 Bone         string
31291                 Pos          Vec
31292                 Rot          [3]float32
31293                 ForceVisible bool
31294         }))(obj)).Bone))) > math.MaxUint16 {
31295                 chk(ErrTooLong)
31296         }
31297         {
31298                 x := uint16(len(([]byte((*(*(struct {
31299                         ParentID     AOID
31300                         Bone         string
31301                         Pos          Vec
31302                         Rot          [3]float32
31303                         ForceVisible bool
31304                 }))(obj)).Bone))))
31305                 write16(w, uint16(x))
31306         }
31307         {
31308                 _, err := w.Write(([]byte((*(*(struct {
31309                         ParentID     AOID
31310                         Bone         string
31311                         Pos          Vec
31312                         Rot          [3]float32
31313                         ForceVisible bool
31314                 }))(obj)).Bone))[:])
31315                 chk(err)
31316         }
31317         if err := pcall(func() {
31318                 ((*(*(struct {
31319                         ParentID     AOID
31320                         Bone         string
31321                         Pos          Vec
31322                         Rot          [3]float32
31323                         ForceVisible bool
31324                 }))(obj)).Pos).serialize(w)
31325         }); err != nil {
31326                 if err == io.EOF {
31327                         chk(io.EOF)
31328                 }
31329                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31330         }
31331         for local368 := range (*(*(struct {
31332                 ParentID     AOID
31333                 Bone         string
31334                 Pos          Vec
31335                 Rot          [3]float32
31336                 ForceVisible bool
31337         }))(obj)).Rot {
31338                 {
31339                         x := ((*(*(struct {
31340                                 ParentID     AOID
31341                                 Bone         string
31342                                 Pos          Vec
31343                                 Rot          [3]float32
31344                                 ForceVisible bool
31345                         }))(obj)).Rot)[local368]
31346                         write32(w, math.Float32bits(x))
31347                 }
31348         }
31349         {
31350                 x := (*(*(struct {
31351                         ParentID     AOID
31352                         Bone         string
31353                         Pos          Vec
31354                         Rot          [3]float32
31355                         ForceVisible bool
31356                 }))(obj)).ForceVisible
31357                 if x {
31358                         write8(w, 1)
31359                 } else {
31360                         write8(w, 0)
31361                 }
31362         }
31363 }
31364
31365 func (obj *AOAttach) deserialize(r io.Reader) {
31366         if err := pcall(func() {
31367                 ((*(*(struct {
31368                         ParentID     AOID
31369                         Bone         string
31370                         Pos          Vec
31371                         Rot          [3]float32
31372                         ForceVisible bool
31373                 }))(obj)).ParentID).deserialize(r)
31374         }); err != nil {
31375                 if err == io.EOF {
31376                         chk(io.EOF)
31377                 }
31378                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
31379         }
31380         var local369 []uint8
31381         var local370 uint16
31382         {
31383                 p := &local370
31384                 *p = read16(r)
31385         }
31386         (local369) = make([]uint8, local370)
31387         {
31388                 _, err := io.ReadFull(r, (local369)[:])
31389                 chk(err)
31390         }
31391         ((*(*(struct {
31392                 ParentID     AOID
31393                 Bone         string
31394                 Pos          Vec
31395                 Rot          [3]float32
31396                 ForceVisible bool
31397         }))(obj)).Bone) = string(local369)
31398         if err := pcall(func() {
31399                 ((*(*(struct {
31400                         ParentID     AOID
31401                         Bone         string
31402                         Pos          Vec
31403                         Rot          [3]float32
31404                         ForceVisible bool
31405                 }))(obj)).Pos).deserialize(r)
31406         }); err != nil {
31407                 if err == io.EOF {
31408                         chk(io.EOF)
31409                 }
31410                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31411         }
31412         for local371 := range (*(*(struct {
31413                 ParentID     AOID
31414                 Bone         string
31415                 Pos          Vec
31416                 Rot          [3]float32
31417                 ForceVisible bool
31418         }))(obj)).Rot {
31419                 {
31420                         p := &((*(*(struct {
31421                                 ParentID     AOID
31422                                 Bone         string
31423                                 Pos          Vec
31424                                 Rot          [3]float32
31425                                 ForceVisible bool
31426                         }))(obj)).Rot)[local371]
31427                         *p = math.Float32frombits(read32(r))
31428                 }
31429         }
31430         {
31431                 p := &(*(*(struct {
31432                         ParentID     AOID
31433                         Bone         string
31434                         Pos          Vec
31435                         Rot          [3]float32
31436                         ForceVisible bool
31437                 }))(obj)).ForceVisible
31438                 switch n := read8(r); n {
31439                 case 0:
31440                         *p = false
31441                 case 1:
31442                         *p = true
31443                 default:
31444                         chk(fmt.Errorf("invalid bool: %d", n))
31445                 }
31446         }
31447 }
31448
31449 func (obj *AOPhysOverride) serialize(w io.Writer) {
31450         {
31451                 x := (*(*(struct {
31452                         Walk, Jump, Gravity float32
31453
31454                         // Player only.
31455                         NoSneak, NoSneakGlitch, OldSneak bool
31456                 }))(obj)).Walk
31457                 write32(w, math.Float32bits(x))
31458         }
31459         {
31460                 x := (*(*(struct {
31461                         Walk, Jump, Gravity float32
31462
31463                         // Player only.
31464                         NoSneak, NoSneakGlitch, OldSneak bool
31465                 }))(obj)).Jump
31466                 write32(w, math.Float32bits(x))
31467         }
31468         {
31469                 x := (*(*(struct {
31470                         Walk, Jump, Gravity float32
31471
31472                         // Player only.
31473                         NoSneak, NoSneakGlitch, OldSneak bool
31474                 }))(obj)).Gravity
31475                 write32(w, math.Float32bits(x))
31476         }
31477         {
31478                 x := (*(*(struct {
31479                         Walk, Jump, Gravity float32
31480
31481                         // Player only.
31482                         NoSneak, NoSneakGlitch, OldSneak bool
31483                 }))(obj)).NoSneak
31484                 if x {
31485                         write8(w, 1)
31486                 } else {
31487                         write8(w, 0)
31488                 }
31489         }
31490         {
31491                 x := (*(*(struct {
31492                         Walk, Jump, Gravity float32
31493
31494                         // Player only.
31495                         NoSneak, NoSneakGlitch, OldSneak bool
31496                 }))(obj)).NoSneakGlitch
31497                 if x {
31498                         write8(w, 1)
31499                 } else {
31500                         write8(w, 0)
31501                 }
31502         }
31503         {
31504                 x := (*(*(struct {
31505                         Walk, Jump, Gravity float32
31506
31507                         // Player only.
31508                         NoSneak, NoSneakGlitch, OldSneak bool
31509                 }))(obj)).OldSneak
31510                 if x {
31511                         write8(w, 1)
31512                 } else {
31513                         write8(w, 0)
31514                 }
31515         }
31516 }
31517
31518 func (obj *AOPhysOverride) deserialize(r io.Reader) {
31519         {
31520                 p := &(*(*(struct {
31521                         Walk, Jump, Gravity float32
31522
31523                         // Player only.
31524                         NoSneak, NoSneakGlitch, OldSneak bool
31525                 }))(obj)).Walk
31526                 *p = math.Float32frombits(read32(r))
31527         }
31528         {
31529                 p := &(*(*(struct {
31530                         Walk, Jump, Gravity float32
31531
31532                         // Player only.
31533                         NoSneak, NoSneakGlitch, OldSneak bool
31534                 }))(obj)).Jump
31535                 *p = math.Float32frombits(read32(r))
31536         }
31537         {
31538                 p := &(*(*(struct {
31539                         Walk, Jump, Gravity float32
31540
31541                         // Player only.
31542                         NoSneak, NoSneakGlitch, OldSneak bool
31543                 }))(obj)).Gravity
31544                 *p = math.Float32frombits(read32(r))
31545         }
31546         {
31547                 p := &(*(*(struct {
31548                         Walk, Jump, Gravity float32
31549
31550                         // Player only.
31551                         NoSneak, NoSneakGlitch, OldSneak bool
31552                 }))(obj)).NoSneak
31553                 switch n := read8(r); n {
31554                 case 0:
31555                         *p = false
31556                 case 1:
31557                         *p = true
31558                 default:
31559                         chk(fmt.Errorf("invalid bool: %d", n))
31560                 }
31561         }
31562         {
31563                 p := &(*(*(struct {
31564                         Walk, Jump, Gravity float32
31565
31566                         // Player only.
31567                         NoSneak, NoSneakGlitch, OldSneak bool
31568                 }))(obj)).NoSneakGlitch
31569                 switch n := read8(r); n {
31570                 case 0:
31571                         *p = false
31572                 case 1:
31573                         *p = true
31574                 default:
31575                         chk(fmt.Errorf("invalid bool: %d", n))
31576                 }
31577         }
31578         {
31579                 p := &(*(*(struct {
31580                         Walk, Jump, Gravity float32
31581
31582                         // Player only.
31583                         NoSneak, NoSneakGlitch, OldSneak bool
31584                 }))(obj)).OldSneak
31585                 switch n := read8(r); n {
31586                 case 0:
31587                         *p = false
31588                 case 1:
31589                         *p = true
31590                 default:
31591                         chk(fmt.Errorf("invalid bool: %d", n))
31592                 }
31593         }
31594 }
31595
31596 func (obj *aoType) serialize(w io.Writer) {
31597         {
31598                 x := *(*(uint8))(obj)
31599                 write8(w, uint8(x))
31600         }
31601 }
31602
31603 func (obj *aoType) deserialize(r io.Reader) {
31604         {
31605                 p := &*(*(uint8))(obj)
31606                 *p = read8(r)
31607         }
31608 }
31609
31610 func (obj *NodeMetaField) serialize(w io.Writer) {
31611         if err := pcall(func() {
31612                 ((*(*(struct {
31613                         Field
31614                         Private bool
31615                 }))(obj)).Field).serialize(w)
31616         }); err != nil {
31617                 if err == io.EOF {
31618                         chk(io.EOF)
31619                 }
31620                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
31621         }
31622         {
31623                 x := (*(*(struct {
31624                         Field
31625                         Private bool
31626                 }))(obj)).Private
31627                 if x {
31628                         write8(w, 1)
31629                 } else {
31630                         write8(w, 0)
31631                 }
31632         }
31633 }
31634
31635 func (obj *NodeMetaField) deserialize(r io.Reader) {
31636         if err := pcall(func() {
31637                 ((*(*(struct {
31638                         Field
31639                         Private bool
31640                 }))(obj)).Field).deserialize(r)
31641         }); err != nil {
31642                 if err == io.EOF {
31643                         chk(io.EOF)
31644                 }
31645                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
31646         }
31647         {
31648                 p := &(*(*(struct {
31649                         Field
31650                         Private bool
31651                 }))(obj)).Private
31652                 switch n := read8(r); n {
31653                 case 0:
31654                         *p = false
31655                 case 1:
31656                         *p = true
31657                 default:
31658                         chk(fmt.Errorf("invalid bool: %d", n))
31659                 }
31660         }
31661 }
31662
31663 func (obj *MinimapType) serialize(w io.Writer) {
31664         {
31665                 x := *(*(uint16))(obj)
31666                 write16(w, uint16(x))
31667         }
31668 }
31669
31670 func (obj *MinimapType) deserialize(r io.Reader) {
31671         {
31672                 p := &*(*(uint16))(obj)
31673                 *p = read16(r)
31674         }
31675 }
31676
31677 func (obj *Param1Type) serialize(w io.Writer) {
31678         {
31679                 x := *(*(uint8))(obj)
31680                 write8(w, uint8(x))
31681         }
31682 }
31683
31684 func (obj *Param1Type) deserialize(r io.Reader) {
31685         {
31686                 p := &*(*(uint8))(obj)
31687                 *p = read8(r)
31688         }
31689 }
31690
31691 func (obj *Param2Type) serialize(w io.Writer) {
31692         {
31693                 x := *(*(uint8))(obj)
31694                 write8(w, uint8(x))
31695         }
31696 }
31697
31698 func (obj *Param2Type) deserialize(r io.Reader) {
31699         {
31700                 p := &*(*(uint8))(obj)
31701                 *p = read8(r)
31702         }
31703 }
31704
31705 func (obj *DrawType) serialize(w io.Writer) {
31706         {
31707                 x := *(*(uint8))(obj)
31708                 write8(w, uint8(x))
31709         }
31710 }
31711
31712 func (obj *DrawType) deserialize(r io.Reader) {
31713         {
31714                 p := &*(*(uint8))(obj)
31715                 *p = read8(r)
31716         }
31717 }
31718
31719 func (obj *TileDef) serialize(w io.Writer) {
31720         {
31721                 local372 := uint8(6)
31722                 {
31723                         x := local372
31724                         write8(w, uint8(x))
31725                 }
31726         }
31727         if err := pcall(func() {
31728                 ((*(*(struct {
31729                         Texture
31730                         Anim  TileAnim
31731                         Flags TileFlags
31732
31733                         //mt:if %s.Flags&TileColor != 0
31734                         R, G, B uint8
31735
31736                         //mt:if %s.Flags&TileScale != 0
31737                         Scale uint8
31738
31739                         //mt:if %s.Flags&TileAlign != 0
31740                         Align AlignType
31741                 }))(obj)).Texture).serialize(w)
31742         }); err != nil {
31743                 if err == io.EOF {
31744                         chk(io.EOF)
31745                 }
31746                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
31747         }
31748         if err := pcall(func() {
31749                 ((*(*(struct {
31750                         Texture
31751                         Anim  TileAnim
31752                         Flags TileFlags
31753
31754                         //mt:if %s.Flags&TileColor != 0
31755                         R, G, B uint8
31756
31757                         //mt:if %s.Flags&TileScale != 0
31758                         Scale uint8
31759
31760                         //mt:if %s.Flags&TileAlign != 0
31761                         Align AlignType
31762                 }))(obj)).Anim).serialize(w)
31763         }); err != nil {
31764                 if err == io.EOF {
31765                         chk(io.EOF)
31766                 }
31767                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
31768         }
31769         if err := pcall(func() {
31770                 ((*(*(struct {
31771                         Texture
31772                         Anim  TileAnim
31773                         Flags TileFlags
31774
31775                         //mt:if %s.Flags&TileColor != 0
31776                         R, G, B uint8
31777
31778                         //mt:if %s.Flags&TileScale != 0
31779                         Scale uint8
31780
31781                         //mt:if %s.Flags&TileAlign != 0
31782                         Align AlignType
31783                 }))(obj)).Flags).serialize(w)
31784         }); err != nil {
31785                 if err == io.EOF {
31786                         chk(io.EOF)
31787                 }
31788                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileFlags", err))
31789         }
31790         if (*(*(struct {
31791                 Texture
31792                 Anim  TileAnim
31793                 Flags TileFlags
31794
31795                 //mt:if %s.Flags&TileColor != 0
31796                 R, G, B uint8
31797
31798                 //mt:if %s.Flags&TileScale != 0
31799                 Scale uint8
31800
31801                 //mt:if %s.Flags&TileAlign != 0
31802                 Align AlignType
31803         }))(obj)).Flags&TileColor != 0 {
31804                 {
31805                         x := (*(*(struct {
31806                                 Texture
31807                                 Anim  TileAnim
31808                                 Flags TileFlags
31809
31810                                 //mt:if %s.Flags&TileColor != 0
31811                                 R, G, B uint8
31812
31813                                 //mt:if %s.Flags&TileScale != 0
31814                                 Scale uint8
31815
31816                                 //mt:if %s.Flags&TileAlign != 0
31817                                 Align AlignType
31818                         }))(obj)).R
31819                         write8(w, uint8(x))
31820                 }
31821                 {
31822                         x := (*(*(struct {
31823                                 Texture
31824                                 Anim  TileAnim
31825                                 Flags TileFlags
31826
31827                                 //mt:if %s.Flags&TileColor != 0
31828                                 R, G, B uint8
31829
31830                                 //mt:if %s.Flags&TileScale != 0
31831                                 Scale uint8
31832
31833                                 //mt:if %s.Flags&TileAlign != 0
31834                                 Align AlignType
31835                         }))(obj)).G
31836                         write8(w, uint8(x))
31837                 }
31838                 {
31839                         x := (*(*(struct {
31840                                 Texture
31841                                 Anim  TileAnim
31842                                 Flags TileFlags
31843
31844                                 //mt:if %s.Flags&TileColor != 0
31845                                 R, G, B uint8
31846
31847                                 //mt:if %s.Flags&TileScale != 0
31848                                 Scale uint8
31849
31850                                 //mt:if %s.Flags&TileAlign != 0
31851                                 Align AlignType
31852                         }))(obj)).B
31853                         write8(w, uint8(x))
31854                 }
31855         }
31856         if (*(*(struct {
31857                 Texture
31858                 Anim  TileAnim
31859                 Flags TileFlags
31860
31861                 //mt:if %s.Flags&TileColor != 0
31862                 R, G, B uint8
31863
31864                 //mt:if %s.Flags&TileScale != 0
31865                 Scale uint8
31866
31867                 //mt:if %s.Flags&TileAlign != 0
31868                 Align AlignType
31869         }))(obj)).Flags&TileScale != 0 {
31870                 {
31871                         x := (*(*(struct {
31872                                 Texture
31873                                 Anim  TileAnim
31874                                 Flags TileFlags
31875
31876                                 //mt:if %s.Flags&TileColor != 0
31877                                 R, G, B uint8
31878
31879                                 //mt:if %s.Flags&TileScale != 0
31880                                 Scale uint8
31881
31882                                 //mt:if %s.Flags&TileAlign != 0
31883                                 Align AlignType
31884                         }))(obj)).Scale
31885                         write8(w, uint8(x))
31886                 }
31887         }
31888         if (*(*(struct {
31889                 Texture
31890                 Anim  TileAnim
31891                 Flags TileFlags
31892
31893                 //mt:if %s.Flags&TileColor != 0
31894                 R, G, B uint8
31895
31896                 //mt:if %s.Flags&TileScale != 0
31897                 Scale uint8
31898
31899                 //mt:if %s.Flags&TileAlign != 0
31900                 Align AlignType
31901         }))(obj)).Flags&TileAlign != 0 {
31902                 if err := pcall(func() {
31903                         ((*(*(struct {
31904                                 Texture
31905                                 Anim  TileAnim
31906                                 Flags TileFlags
31907
31908                                 //mt:if %s.Flags&TileColor != 0
31909                                 R, G, B uint8
31910
31911                                 //mt:if %s.Flags&TileScale != 0
31912                                 Scale uint8
31913
31914                                 //mt:if %s.Flags&TileAlign != 0
31915                                 Align AlignType
31916                         }))(obj)).Align).serialize(w)
31917                 }); err != nil {
31918                         if err == io.EOF {
31919                                 chk(io.EOF)
31920                         }
31921                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlignType", err))
31922                 }
31923         }
31924 }
31925
31926 func (obj *TileDef) deserialize(r io.Reader) {
31927         {
31928                 var local373 uint8
31929                 local374 := uint8(6)
31930                 {
31931                         p := &local373
31932                         *p = read8(r)
31933                 }
31934                 if local373 != local374 {
31935                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local373))
31936                 }
31937         }
31938         if err := pcall(func() {
31939                 ((*(*(struct {
31940                         Texture
31941                         Anim  TileAnim
31942                         Flags TileFlags
31943
31944                         //mt:if %s.Flags&TileColor != 0
31945                         R, G, B uint8
31946
31947                         //mt:if %s.Flags&TileScale != 0
31948                         Scale uint8
31949
31950                         //mt:if %s.Flags&TileAlign != 0
31951                         Align AlignType
31952                 }))(obj)).Texture).deserialize(r)
31953         }); err != nil {
31954                 if err == io.EOF {
31955                         chk(io.EOF)
31956                 }
31957                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
31958         }
31959         if err := pcall(func() {
31960                 ((*(*(struct {
31961                         Texture
31962                         Anim  TileAnim
31963                         Flags TileFlags
31964
31965                         //mt:if %s.Flags&TileColor != 0
31966                         R, G, B uint8
31967
31968                         //mt:if %s.Flags&TileScale != 0
31969                         Scale uint8
31970
31971                         //mt:if %s.Flags&TileAlign != 0
31972                         Align AlignType
31973                 }))(obj)).Anim).deserialize(r)
31974         }); err != nil {
31975                 if err == io.EOF {
31976                         chk(io.EOF)
31977                 }
31978                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
31979         }
31980         if err := pcall(func() {
31981                 ((*(*(struct {
31982                         Texture
31983                         Anim  TileAnim
31984                         Flags TileFlags
31985
31986                         //mt:if %s.Flags&TileColor != 0
31987                         R, G, B uint8
31988
31989                         //mt:if %s.Flags&TileScale != 0
31990                         Scale uint8
31991
31992                         //mt:if %s.Flags&TileAlign != 0
31993                         Align AlignType
31994                 }))(obj)).Flags).deserialize(r)
31995         }); err != nil {
31996                 if err == io.EOF {
31997                         chk(io.EOF)
31998                 }
31999                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileFlags", err))
32000         }
32001         if (*(*(struct {
32002                 Texture
32003                 Anim  TileAnim
32004                 Flags TileFlags
32005
32006                 //mt:if %s.Flags&TileColor != 0
32007                 R, G, B uint8
32008
32009                 //mt:if %s.Flags&TileScale != 0
32010                 Scale uint8
32011
32012                 //mt:if %s.Flags&TileAlign != 0
32013                 Align AlignType
32014         }))(obj)).Flags&TileColor != 0 {
32015                 {
32016                         p := &(*(*(struct {
32017                                 Texture
32018                                 Anim  TileAnim
32019                                 Flags TileFlags
32020
32021                                 //mt:if %s.Flags&TileColor != 0
32022                                 R, G, B uint8
32023
32024                                 //mt:if %s.Flags&TileScale != 0
32025                                 Scale uint8
32026
32027                                 //mt:if %s.Flags&TileAlign != 0
32028                                 Align AlignType
32029                         }))(obj)).R
32030                         *p = read8(r)
32031                 }
32032                 {
32033                         p := &(*(*(struct {
32034                                 Texture
32035                                 Anim  TileAnim
32036                                 Flags TileFlags
32037
32038                                 //mt:if %s.Flags&TileColor != 0
32039                                 R, G, B uint8
32040
32041                                 //mt:if %s.Flags&TileScale != 0
32042                                 Scale uint8
32043
32044                                 //mt:if %s.Flags&TileAlign != 0
32045                                 Align AlignType
32046                         }))(obj)).G
32047                         *p = read8(r)
32048                 }
32049                 {
32050                         p := &(*(*(struct {
32051                                 Texture
32052                                 Anim  TileAnim
32053                                 Flags TileFlags
32054
32055                                 //mt:if %s.Flags&TileColor != 0
32056                                 R, G, B uint8
32057
32058                                 //mt:if %s.Flags&TileScale != 0
32059                                 Scale uint8
32060
32061                                 //mt:if %s.Flags&TileAlign != 0
32062                                 Align AlignType
32063                         }))(obj)).B
32064                         *p = read8(r)
32065                 }
32066         }
32067         if (*(*(struct {
32068                 Texture
32069                 Anim  TileAnim
32070                 Flags TileFlags
32071
32072                 //mt:if %s.Flags&TileColor != 0
32073                 R, G, B uint8
32074
32075                 //mt:if %s.Flags&TileScale != 0
32076                 Scale uint8
32077
32078                 //mt:if %s.Flags&TileAlign != 0
32079                 Align AlignType
32080         }))(obj)).Flags&TileScale != 0 {
32081                 {
32082                         p := &(*(*(struct {
32083                                 Texture
32084                                 Anim  TileAnim
32085                                 Flags TileFlags
32086
32087                                 //mt:if %s.Flags&TileColor != 0
32088                                 R, G, B uint8
32089
32090                                 //mt:if %s.Flags&TileScale != 0
32091                                 Scale uint8
32092
32093                                 //mt:if %s.Flags&TileAlign != 0
32094                                 Align AlignType
32095                         }))(obj)).Scale
32096                         *p = read8(r)
32097                 }
32098         }
32099         if (*(*(struct {
32100                 Texture
32101                 Anim  TileAnim
32102                 Flags TileFlags
32103
32104                 //mt:if %s.Flags&TileColor != 0
32105                 R, G, B uint8
32106
32107                 //mt:if %s.Flags&TileScale != 0
32108                 Scale uint8
32109
32110                 //mt:if %s.Flags&TileAlign != 0
32111                 Align AlignType
32112         }))(obj)).Flags&TileAlign != 0 {
32113                 if err := pcall(func() {
32114                         ((*(*(struct {
32115                                 Texture
32116                                 Anim  TileAnim
32117                                 Flags TileFlags
32118
32119                                 //mt:if %s.Flags&TileColor != 0
32120                                 R, G, B uint8
32121
32122                                 //mt:if %s.Flags&TileScale != 0
32123                                 Scale uint8
32124
32125                                 //mt:if %s.Flags&TileAlign != 0
32126                                 Align AlignType
32127                         }))(obj)).Align).deserialize(r)
32128                 }); err != nil {
32129                         if err == io.EOF {
32130                                 chk(io.EOF)
32131                         }
32132                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlignType", err))
32133                 }
32134         }
32135 }
32136
32137 func (obj *WaveType) serialize(w io.Writer) {
32138         {
32139                 x := *(*(uint8))(obj)
32140                 write8(w, uint8(x))
32141         }
32142 }
32143
32144 func (obj *WaveType) deserialize(r io.Reader) {
32145         {
32146                 p := &*(*(uint8))(obj)
32147                 *p = read8(r)
32148         }
32149 }
32150
32151 func (obj *LiquidType) serialize(w io.Writer) {
32152         {
32153                 x := *(*(uint8))(obj)
32154                 write8(w, uint8(x))
32155         }
32156 }
32157
32158 func (obj *LiquidType) deserialize(r io.Reader) {
32159         {
32160                 p := &*(*(uint8))(obj)
32161                 *p = read8(r)
32162         }
32163 }
32164
32165 func (obj *NodeBox) serialize(w io.Writer) {
32166         {
32167                 local375 := uint8(6)
32168                 {
32169                         x := local375
32170                         write8(w, uint8(x))
32171                 }
32172         }
32173         if err := pcall(func() {
32174                 ((*(*(struct {
32175                         Type NodeBoxType
32176
32177                         //mt:if %s.Type == MountedBox
32178                         WallTop, WallBot, WallSides Box
32179
32180                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32181                         Fixed []Box
32182
32183                         //mt:if %s.Type == ConnectedBox
32184                         ConnDirs, DiscoDirs  DirBoxes
32185                         DiscoAll, DiscoSides []Box
32186                 }))(obj)).Type).serialize(w)
32187         }); err != nil {
32188                 if err == io.EOF {
32189                         chk(io.EOF)
32190                 }
32191                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBoxType", err))
32192         }
32193         if !((*(*(struct {
32194                 Type NodeBoxType
32195
32196                 //mt:if %s.Type == MountedBox
32197                 WallTop, WallBot, WallSides Box
32198
32199                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32200                 Fixed []Box
32201
32202                 //mt:if %s.Type == ConnectedBox
32203                 ConnDirs, DiscoDirs  DirBoxes
32204                 DiscoAll, DiscoSides []Box
32205         }))(obj)).Type < maxBox) {
32206                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32207         }
32208         if (*(*(struct {
32209                 Type NodeBoxType
32210
32211                 //mt:if %s.Type == MountedBox
32212                 WallTop, WallBot, WallSides Box
32213
32214                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32215                 Fixed []Box
32216
32217                 //mt:if %s.Type == ConnectedBox
32218                 ConnDirs, DiscoDirs  DirBoxes
32219                 DiscoAll, DiscoSides []Box
32220         }))(obj)).Type == MountedBox {
32221                 if err := pcall(func() {
32222                         ((*(*(struct {
32223                                 Type NodeBoxType
32224
32225                                 //mt:if %s.Type == MountedBox
32226                                 WallTop, WallBot, WallSides Box
32227
32228                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32229                                 Fixed []Box
32230
32231                                 //mt:if %s.Type == ConnectedBox
32232                                 ConnDirs, DiscoDirs  DirBoxes
32233                                 DiscoAll, DiscoSides []Box
32234                         }))(obj)).WallTop).serialize(w)
32235                 }); err != nil {
32236                         if err == io.EOF {
32237                                 chk(io.EOF)
32238                         }
32239                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32240                 }
32241                 if err := pcall(func() {
32242                         ((*(*(struct {
32243                                 Type NodeBoxType
32244
32245                                 //mt:if %s.Type == MountedBox
32246                                 WallTop, WallBot, WallSides Box
32247
32248                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32249                                 Fixed []Box
32250
32251                                 //mt:if %s.Type == ConnectedBox
32252                                 ConnDirs, DiscoDirs  DirBoxes
32253                                 DiscoAll, DiscoSides []Box
32254                         }))(obj)).WallBot).serialize(w)
32255                 }); err != nil {
32256                         if err == io.EOF {
32257                                 chk(io.EOF)
32258                         }
32259                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32260                 }
32261                 if err := pcall(func() {
32262                         ((*(*(struct {
32263                                 Type NodeBoxType
32264
32265                                 //mt:if %s.Type == MountedBox
32266                                 WallTop, WallBot, WallSides Box
32267
32268                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32269                                 Fixed []Box
32270
32271                                 //mt:if %s.Type == ConnectedBox
32272                                 ConnDirs, DiscoDirs  DirBoxes
32273                                 DiscoAll, DiscoSides []Box
32274                         }))(obj)).WallSides).serialize(w)
32275                 }); err != nil {
32276                         if err == io.EOF {
32277                                 chk(io.EOF)
32278                         }
32279                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32280                 }
32281         }
32282         if t := (*(*(struct {
32283                 Type NodeBoxType
32284
32285                 //mt:if %s.Type == MountedBox
32286                 WallTop, WallBot, WallSides Box
32287
32288                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32289                 Fixed []Box
32290
32291                 //mt:if %s.Type == ConnectedBox
32292                 ConnDirs, DiscoDirs  DirBoxes
32293                 DiscoAll, DiscoSides []Box
32294         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32295                 if len(((*(*(struct {
32296                         Type NodeBoxType
32297
32298                         //mt:if %s.Type == MountedBox
32299                         WallTop, WallBot, WallSides Box
32300
32301                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32302                         Fixed []Box
32303
32304                         //mt:if %s.Type == ConnectedBox
32305                         ConnDirs, DiscoDirs  DirBoxes
32306                         DiscoAll, DiscoSides []Box
32307                 }))(obj)).Fixed)) > math.MaxUint16 {
32308                         chk(ErrTooLong)
32309                 }
32310                 {
32311                         x := uint16(len(((*(*(struct {
32312                                 Type NodeBoxType
32313
32314                                 //mt:if %s.Type == MountedBox
32315                                 WallTop, WallBot, WallSides Box
32316
32317                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32318                                 Fixed []Box
32319
32320                                 //mt:if %s.Type == ConnectedBox
32321                                 ConnDirs, DiscoDirs  DirBoxes
32322                                 DiscoAll, DiscoSides []Box
32323                         }))(obj)).Fixed)))
32324                         write16(w, uint16(x))
32325                 }
32326                 for local376 := range (*(*(struct {
32327                         Type NodeBoxType
32328
32329                         //mt:if %s.Type == MountedBox
32330                         WallTop, WallBot, WallSides Box
32331
32332                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32333                         Fixed []Box
32334
32335                         //mt:if %s.Type == ConnectedBox
32336                         ConnDirs, DiscoDirs  DirBoxes
32337                         DiscoAll, DiscoSides []Box
32338                 }))(obj)).Fixed {
32339                         if err := pcall(func() {
32340                                 (((*(*(struct {
32341                                         Type NodeBoxType
32342
32343                                         //mt:if %s.Type == MountedBox
32344                                         WallTop, WallBot, WallSides Box
32345
32346                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32347                                         Fixed []Box
32348
32349                                         //mt:if %s.Type == ConnectedBox
32350                                         ConnDirs, DiscoDirs  DirBoxes
32351                                         DiscoAll, DiscoSides []Box
32352                                 }))(obj)).Fixed)[local376]).serialize(w)
32353                         }); err != nil {
32354                                 if err == io.EOF {
32355                                         chk(io.EOF)
32356                                 }
32357                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32358                         }
32359                 }
32360         }
32361         if (*(*(struct {
32362                 Type NodeBoxType
32363
32364                 //mt:if %s.Type == MountedBox
32365                 WallTop, WallBot, WallSides Box
32366
32367                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32368                 Fixed []Box
32369
32370                 //mt:if %s.Type == ConnectedBox
32371                 ConnDirs, DiscoDirs  DirBoxes
32372                 DiscoAll, DiscoSides []Box
32373         }))(obj)).Type == ConnectedBox {
32374                 if err := pcall(func() {
32375                         ((*(*(struct {
32376                                 Type NodeBoxType
32377
32378                                 //mt:if %s.Type == MountedBox
32379                                 WallTop, WallBot, WallSides Box
32380
32381                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32382                                 Fixed []Box
32383
32384                                 //mt:if %s.Type == ConnectedBox
32385                                 ConnDirs, DiscoDirs  DirBoxes
32386                                 DiscoAll, DiscoSides []Box
32387                         }))(obj)).ConnDirs).serialize(w)
32388                 }); err != nil {
32389                         if err == io.EOF {
32390                                 chk(io.EOF)
32391                         }
32392                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32393                 }
32394                 if err := pcall(func() {
32395                         ((*(*(struct {
32396                                 Type NodeBoxType
32397
32398                                 //mt:if %s.Type == MountedBox
32399                                 WallTop, WallBot, WallSides Box
32400
32401                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32402                                 Fixed []Box
32403
32404                                 //mt:if %s.Type == ConnectedBox
32405                                 ConnDirs, DiscoDirs  DirBoxes
32406                                 DiscoAll, DiscoSides []Box
32407                         }))(obj)).DiscoDirs).serialize(w)
32408                 }); err != nil {
32409                         if err == io.EOF {
32410                                 chk(io.EOF)
32411                         }
32412                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32413                 }
32414                 if len(((*(*(struct {
32415                         Type NodeBoxType
32416
32417                         //mt:if %s.Type == MountedBox
32418                         WallTop, WallBot, WallSides Box
32419
32420                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32421                         Fixed []Box
32422
32423                         //mt:if %s.Type == ConnectedBox
32424                         ConnDirs, DiscoDirs  DirBoxes
32425                         DiscoAll, DiscoSides []Box
32426                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32427                         chk(ErrTooLong)
32428                 }
32429                 {
32430                         x := uint16(len(((*(*(struct {
32431                                 Type NodeBoxType
32432
32433                                 //mt:if %s.Type == MountedBox
32434                                 WallTop, WallBot, WallSides Box
32435
32436                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32437                                 Fixed []Box
32438
32439                                 //mt:if %s.Type == ConnectedBox
32440                                 ConnDirs, DiscoDirs  DirBoxes
32441                                 DiscoAll, DiscoSides []Box
32442                         }))(obj)).DiscoAll)))
32443                         write16(w, uint16(x))
32444                 }
32445                 for local377 := range (*(*(struct {
32446                         Type NodeBoxType
32447
32448                         //mt:if %s.Type == MountedBox
32449                         WallTop, WallBot, WallSides Box
32450
32451                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32452                         Fixed []Box
32453
32454                         //mt:if %s.Type == ConnectedBox
32455                         ConnDirs, DiscoDirs  DirBoxes
32456                         DiscoAll, DiscoSides []Box
32457                 }))(obj)).DiscoAll {
32458                         if err := pcall(func() {
32459                                 (((*(*(struct {
32460                                         Type NodeBoxType
32461
32462                                         //mt:if %s.Type == MountedBox
32463                                         WallTop, WallBot, WallSides Box
32464
32465                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32466                                         Fixed []Box
32467
32468                                         //mt:if %s.Type == ConnectedBox
32469                                         ConnDirs, DiscoDirs  DirBoxes
32470                                         DiscoAll, DiscoSides []Box
32471                                 }))(obj)).DiscoAll)[local377]).serialize(w)
32472                         }); err != nil {
32473                                 if err == io.EOF {
32474                                         chk(io.EOF)
32475                                 }
32476                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32477                         }
32478                 }
32479                 if len(((*(*(struct {
32480                         Type NodeBoxType
32481
32482                         //mt:if %s.Type == MountedBox
32483                         WallTop, WallBot, WallSides Box
32484
32485                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32486                         Fixed []Box
32487
32488                         //mt:if %s.Type == ConnectedBox
32489                         ConnDirs, DiscoDirs  DirBoxes
32490                         DiscoAll, DiscoSides []Box
32491                 }))(obj)).DiscoSides)) > math.MaxUint16 {
32492                         chk(ErrTooLong)
32493                 }
32494                 {
32495                         x := uint16(len(((*(*(struct {
32496                                 Type NodeBoxType
32497
32498                                 //mt:if %s.Type == MountedBox
32499                                 WallTop, WallBot, WallSides Box
32500
32501                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32502                                 Fixed []Box
32503
32504                                 //mt:if %s.Type == ConnectedBox
32505                                 ConnDirs, DiscoDirs  DirBoxes
32506                                 DiscoAll, DiscoSides []Box
32507                         }))(obj)).DiscoSides)))
32508                         write16(w, uint16(x))
32509                 }
32510                 for local378 := range (*(*(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)).DiscoSides {
32523                         if err := pcall(func() {
32524                                 (((*(*(struct {
32525                                         Type NodeBoxType
32526
32527                                         //mt:if %s.Type == MountedBox
32528                                         WallTop, WallBot, WallSides Box
32529
32530                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32531                                         Fixed []Box
32532
32533                                         //mt:if %s.Type == ConnectedBox
32534                                         ConnDirs, DiscoDirs  DirBoxes
32535                                         DiscoAll, DiscoSides []Box
32536                                 }))(obj)).DiscoSides)[local378]).serialize(w)
32537                         }); err != nil {
32538                                 if err == io.EOF {
32539                                         chk(io.EOF)
32540                                 }
32541                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32542                         }
32543                 }
32544         }
32545 }
32546
32547 func (obj *NodeBox) deserialize(r io.Reader) {
32548         {
32549                 var local379 uint8
32550                 local380 := uint8(6)
32551                 {
32552                         p := &local379
32553                         *p = read8(r)
32554                 }
32555                 if local379 != local380 {
32556                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local379))
32557                 }
32558         }
32559         if err := pcall(func() {
32560                 ((*(*(struct {
32561                         Type NodeBoxType
32562
32563                         //mt:if %s.Type == MountedBox
32564                         WallTop, WallBot, WallSides Box
32565
32566                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32567                         Fixed []Box
32568
32569                         //mt:if %s.Type == ConnectedBox
32570                         ConnDirs, DiscoDirs  DirBoxes
32571                         DiscoAll, DiscoSides []Box
32572                 }))(obj)).Type).deserialize(r)
32573         }); err != nil {
32574                 if err == io.EOF {
32575                         chk(io.EOF)
32576                 }
32577                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBoxType", err))
32578         }
32579         if !((*(*(struct {
32580                 Type NodeBoxType
32581
32582                 //mt:if %s.Type == MountedBox
32583                 WallTop, WallBot, WallSides Box
32584
32585                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32586                 Fixed []Box
32587
32588                 //mt:if %s.Type == ConnectedBox
32589                 ConnDirs, DiscoDirs  DirBoxes
32590                 DiscoAll, DiscoSides []Box
32591         }))(obj)).Type < maxBox) {
32592                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32593         }
32594         if (*(*(struct {
32595                 Type NodeBoxType
32596
32597                 //mt:if %s.Type == MountedBox
32598                 WallTop, WallBot, WallSides Box
32599
32600                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32601                 Fixed []Box
32602
32603                 //mt:if %s.Type == ConnectedBox
32604                 ConnDirs, DiscoDirs  DirBoxes
32605                 DiscoAll, DiscoSides []Box
32606         }))(obj)).Type == MountedBox {
32607                 if err := pcall(func() {
32608                         ((*(*(struct {
32609                                 Type NodeBoxType
32610
32611                                 //mt:if %s.Type == MountedBox
32612                                 WallTop, WallBot, WallSides Box
32613
32614                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32615                                 Fixed []Box
32616
32617                                 //mt:if %s.Type == ConnectedBox
32618                                 ConnDirs, DiscoDirs  DirBoxes
32619                                 DiscoAll, DiscoSides []Box
32620                         }))(obj)).WallTop).deserialize(r)
32621                 }); err != nil {
32622                         if err == io.EOF {
32623                                 chk(io.EOF)
32624                         }
32625                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32626                 }
32627                 if err := pcall(func() {
32628                         ((*(*(struct {
32629                                 Type NodeBoxType
32630
32631                                 //mt:if %s.Type == MountedBox
32632                                 WallTop, WallBot, WallSides Box
32633
32634                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32635                                 Fixed []Box
32636
32637                                 //mt:if %s.Type == ConnectedBox
32638                                 ConnDirs, DiscoDirs  DirBoxes
32639                                 DiscoAll, DiscoSides []Box
32640                         }))(obj)).WallBot).deserialize(r)
32641                 }); err != nil {
32642                         if err == io.EOF {
32643                                 chk(io.EOF)
32644                         }
32645                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32646                 }
32647                 if err := pcall(func() {
32648                         ((*(*(struct {
32649                                 Type NodeBoxType
32650
32651                                 //mt:if %s.Type == MountedBox
32652                                 WallTop, WallBot, WallSides Box
32653
32654                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32655                                 Fixed []Box
32656
32657                                 //mt:if %s.Type == ConnectedBox
32658                                 ConnDirs, DiscoDirs  DirBoxes
32659                                 DiscoAll, DiscoSides []Box
32660                         }))(obj)).WallSides).deserialize(r)
32661                 }); err != nil {
32662                         if err == io.EOF {
32663                                 chk(io.EOF)
32664                         }
32665                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32666                 }
32667         }
32668         if t := (*(*(struct {
32669                 Type NodeBoxType
32670
32671                 //mt:if %s.Type == MountedBox
32672                 WallTop, WallBot, WallSides Box
32673
32674                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32675                 Fixed []Box
32676
32677                 //mt:if %s.Type == ConnectedBox
32678                 ConnDirs, DiscoDirs  DirBoxes
32679                 DiscoAll, DiscoSides []Box
32680         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32681                 var local381 uint16
32682                 {
32683                         p := &local381
32684                         *p = read16(r)
32685                 }
32686                 ((*(*(struct {
32687                         Type NodeBoxType
32688
32689                         //mt:if %s.Type == MountedBox
32690                         WallTop, WallBot, WallSides Box
32691
32692                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32693                         Fixed []Box
32694
32695                         //mt:if %s.Type == ConnectedBox
32696                         ConnDirs, DiscoDirs  DirBoxes
32697                         DiscoAll, DiscoSides []Box
32698                 }))(obj)).Fixed) = make([]Box, local381)
32699                 for local382 := range (*(*(struct {
32700                         Type NodeBoxType
32701
32702                         //mt:if %s.Type == MountedBox
32703                         WallTop, WallBot, WallSides Box
32704
32705                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32706                         Fixed []Box
32707
32708                         //mt:if %s.Type == ConnectedBox
32709                         ConnDirs, DiscoDirs  DirBoxes
32710                         DiscoAll, DiscoSides []Box
32711                 }))(obj)).Fixed {
32712                         if err := pcall(func() {
32713                                 (((*(*(struct {
32714                                         Type NodeBoxType
32715
32716                                         //mt:if %s.Type == MountedBox
32717                                         WallTop, WallBot, WallSides Box
32718
32719                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32720                                         Fixed []Box
32721
32722                                         //mt:if %s.Type == ConnectedBox
32723                                         ConnDirs, DiscoDirs  DirBoxes
32724                                         DiscoAll, DiscoSides []Box
32725                                 }))(obj)).Fixed)[local382]).deserialize(r)
32726                         }); err != nil {
32727                                 if err == io.EOF {
32728                                         chk(io.EOF)
32729                                 }
32730                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32731                         }
32732                 }
32733         }
32734         if (*(*(struct {
32735                 Type NodeBoxType
32736
32737                 //mt:if %s.Type == MountedBox
32738                 WallTop, WallBot, WallSides Box
32739
32740                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32741                 Fixed []Box
32742
32743                 //mt:if %s.Type == ConnectedBox
32744                 ConnDirs, DiscoDirs  DirBoxes
32745                 DiscoAll, DiscoSides []Box
32746         }))(obj)).Type == ConnectedBox {
32747                 if err := pcall(func() {
32748                         ((*(*(struct {
32749                                 Type NodeBoxType
32750
32751                                 //mt:if %s.Type == MountedBox
32752                                 WallTop, WallBot, WallSides Box
32753
32754                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32755                                 Fixed []Box
32756
32757                                 //mt:if %s.Type == ConnectedBox
32758                                 ConnDirs, DiscoDirs  DirBoxes
32759                                 DiscoAll, DiscoSides []Box
32760                         }))(obj)).ConnDirs).deserialize(r)
32761                 }); err != nil {
32762                         if err == io.EOF {
32763                                 chk(io.EOF)
32764                         }
32765                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32766                 }
32767                 if err := pcall(func() {
32768                         ((*(*(struct {
32769                                 Type NodeBoxType
32770
32771                                 //mt:if %s.Type == MountedBox
32772                                 WallTop, WallBot, WallSides Box
32773
32774                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32775                                 Fixed []Box
32776
32777                                 //mt:if %s.Type == ConnectedBox
32778                                 ConnDirs, DiscoDirs  DirBoxes
32779                                 DiscoAll, DiscoSides []Box
32780                         }))(obj)).DiscoDirs).deserialize(r)
32781                 }); err != nil {
32782                         if err == io.EOF {
32783                                 chk(io.EOF)
32784                         }
32785                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32786                 }
32787                 var local383 uint16
32788                 {
32789                         p := &local383
32790                         *p = read16(r)
32791                 }
32792                 ((*(*(struct {
32793                         Type NodeBoxType
32794
32795                         //mt:if %s.Type == MountedBox
32796                         WallTop, WallBot, WallSides Box
32797
32798                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32799                         Fixed []Box
32800
32801                         //mt:if %s.Type == ConnectedBox
32802                         ConnDirs, DiscoDirs  DirBoxes
32803                         DiscoAll, DiscoSides []Box
32804                 }))(obj)).DiscoAll) = make([]Box, local383)
32805                 for local384 := range (*(*(struct {
32806                         Type NodeBoxType
32807
32808                         //mt:if %s.Type == MountedBox
32809                         WallTop, WallBot, WallSides Box
32810
32811                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32812                         Fixed []Box
32813
32814                         //mt:if %s.Type == ConnectedBox
32815                         ConnDirs, DiscoDirs  DirBoxes
32816                         DiscoAll, DiscoSides []Box
32817                 }))(obj)).DiscoAll {
32818                         if err := pcall(func() {
32819                                 (((*(*(struct {
32820                                         Type NodeBoxType
32821
32822                                         //mt:if %s.Type == MountedBox
32823                                         WallTop, WallBot, WallSides Box
32824
32825                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32826                                         Fixed []Box
32827
32828                                         //mt:if %s.Type == ConnectedBox
32829                                         ConnDirs, DiscoDirs  DirBoxes
32830                                         DiscoAll, DiscoSides []Box
32831                                 }))(obj)).DiscoAll)[local384]).deserialize(r)
32832                         }); err != nil {
32833                                 if err == io.EOF {
32834                                         chk(io.EOF)
32835                                 }
32836                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32837                         }
32838                 }
32839                 var local385 uint16
32840                 {
32841                         p := &local385
32842                         *p = read16(r)
32843                 }
32844                 ((*(*(struct {
32845                         Type NodeBoxType
32846
32847                         //mt:if %s.Type == MountedBox
32848                         WallTop, WallBot, WallSides Box
32849
32850                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32851                         Fixed []Box
32852
32853                         //mt:if %s.Type == ConnectedBox
32854                         ConnDirs, DiscoDirs  DirBoxes
32855                         DiscoAll, DiscoSides []Box
32856                 }))(obj)).DiscoSides) = make([]Box, local385)
32857                 for local386 := range (*(*(struct {
32858                         Type NodeBoxType
32859
32860                         //mt:if %s.Type == MountedBox
32861                         WallTop, WallBot, WallSides Box
32862
32863                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32864                         Fixed []Box
32865
32866                         //mt:if %s.Type == ConnectedBox
32867                         ConnDirs, DiscoDirs  DirBoxes
32868                         DiscoAll, DiscoSides []Box
32869                 }))(obj)).DiscoSides {
32870                         if err := pcall(func() {
32871                                 (((*(*(struct {
32872                                         Type NodeBoxType
32873
32874                                         //mt:if %s.Type == MountedBox
32875                                         WallTop, WallBot, WallSides Box
32876
32877                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32878                                         Fixed []Box
32879
32880                                         //mt:if %s.Type == ConnectedBox
32881                                         ConnDirs, DiscoDirs  DirBoxes
32882                                         DiscoAll, DiscoSides []Box
32883                                 }))(obj)).DiscoSides)[local386]).deserialize(r)
32884                         }); err != nil {
32885                                 if err == io.EOF {
32886                                         chk(io.EOF)
32887                                 }
32888                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32889                         }
32890                 }
32891         }
32892 }
32893
32894 func (obj *SoundDef) serialize(w io.Writer) {
32895         if len(([]byte((*(*(struct {
32896                 Name              string
32897                 Gain, Pitch, Fade float32
32898         }))(obj)).Name))) > math.MaxUint16 {
32899                 chk(ErrTooLong)
32900         }
32901         {
32902                 x := uint16(len(([]byte((*(*(struct {
32903                         Name              string
32904                         Gain, Pitch, Fade float32
32905                 }))(obj)).Name))))
32906                 write16(w, uint16(x))
32907         }
32908         {
32909                 _, err := w.Write(([]byte((*(*(struct {
32910                         Name              string
32911                         Gain, Pitch, Fade float32
32912                 }))(obj)).Name))[:])
32913                 chk(err)
32914         }
32915         {
32916                 x := (*(*(struct {
32917                         Name              string
32918                         Gain, Pitch, Fade float32
32919                 }))(obj)).Gain
32920                 write32(w, math.Float32bits(x))
32921         }
32922         {
32923                 x := (*(*(struct {
32924                         Name              string
32925                         Gain, Pitch, Fade float32
32926                 }))(obj)).Pitch
32927                 write32(w, math.Float32bits(x))
32928         }
32929         {
32930                 x := (*(*(struct {
32931                         Name              string
32932                         Gain, Pitch, Fade float32
32933                 }))(obj)).Fade
32934                 write32(w, math.Float32bits(x))
32935         }
32936 }
32937
32938 func (obj *SoundDef) deserialize(r io.Reader) {
32939         var local387 []uint8
32940         var local388 uint16
32941         {
32942                 p := &local388
32943                 *p = read16(r)
32944         }
32945         (local387) = make([]uint8, local388)
32946         {
32947                 _, err := io.ReadFull(r, (local387)[:])
32948                 chk(err)
32949         }
32950         ((*(*(struct {
32951                 Name              string
32952                 Gain, Pitch, Fade float32
32953         }))(obj)).Name) = string(local387)
32954         {
32955                 p := &(*(*(struct {
32956                         Name              string
32957                         Gain, Pitch, Fade float32
32958                 }))(obj)).Gain
32959                 *p = math.Float32frombits(read32(r))
32960         }
32961         {
32962                 p := &(*(*(struct {
32963                         Name              string
32964                         Gain, Pitch, Fade float32
32965                 }))(obj)).Pitch
32966                 *p = math.Float32frombits(read32(r))
32967         }
32968         {
32969                 p := &(*(*(struct {
32970                         Name              string
32971                         Gain, Pitch, Fade float32
32972                 }))(obj)).Fade
32973                 *p = math.Float32frombits(read32(r))
32974         }
32975 }
32976
32977 func (obj *AlphaUse) serialize(w io.Writer) {
32978         {
32979                 x := *(*(uint8))(obj)
32980                 write8(w, uint8(x))
32981         }
32982 }
32983
32984 func (obj *AlphaUse) deserialize(r io.Reader) {
32985         {
32986                 p := &*(*(uint8))(obj)
32987                 *p = read8(r)
32988         }
32989 }
32990
32991 func (obj *Keys) serialize(w io.Writer) {
32992         {
32993                 x := *(*(uint32))(obj)
32994                 write32(w, uint32(x))
32995         }
32996 }
32997
32998 func (obj *Keys) deserialize(r io.Reader) {
32999         {
33000                 p := &*(*(uint32))(obj)
33001                 *p = read32(r)
33002         }
33003 }
33004
33005 func (obj *MapBlkFlags) serialize(w io.Writer) {
33006         {
33007                 x := *(*(uint8))(obj)
33008                 write8(w, uint8(x))
33009         }
33010 }
33011
33012 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33013         {
33014                 p := &*(*(uint8))(obj)
33015                 *p = read8(r)
33016         }
33017 }
33018
33019 func (obj *LitFromBlks) serialize(w io.Writer) {
33020         {
33021                 x := *(*(uint16))(obj)
33022                 write16(w, uint16(x))
33023         }
33024 }
33025
33026 func (obj *LitFromBlks) deserialize(r io.Reader) {
33027         {
33028                 p := &*(*(uint16))(obj)
33029                 *p = read16(r)
33030         }
33031 }
33032
33033 func (obj *AOInitData) serialize(w io.Writer) {
33034         {
33035                 local389 := uint8(1)
33036                 {
33037                         x := local389
33038                         write8(w, uint8(x))
33039                 }
33040         }
33041         if len(([]byte((*(*(struct {
33042
33043                 // For players.
33044                 Name     string
33045                 IsPlayer bool
33046
33047                 ID AOID
33048
33049                 Pos
33050                 Rot [3]float32
33051
33052                 HP uint16
33053
33054                 // See (de)serialize.fmt.
33055                 Msgs []AOMsg
33056         }))(obj)).Name))) > math.MaxUint16 {
33057                 chk(ErrTooLong)
33058         }
33059         {
33060                 x := uint16(len(([]byte((*(*(struct {
33061
33062                         // For players.
33063                         Name     string
33064                         IsPlayer bool
33065
33066                         ID AOID
33067
33068                         Pos
33069                         Rot [3]float32
33070
33071                         HP uint16
33072
33073                         // See (de)serialize.fmt.
33074                         Msgs []AOMsg
33075                 }))(obj)).Name))))
33076                 write16(w, uint16(x))
33077         }
33078         {
33079                 _, err := w.Write(([]byte((*(*(struct {
33080
33081                         // For players.
33082                         Name     string
33083                         IsPlayer bool
33084
33085                         ID AOID
33086
33087                         Pos
33088                         Rot [3]float32
33089
33090                         HP uint16
33091
33092                         // See (de)serialize.fmt.
33093                         Msgs []AOMsg
33094                 }))(obj)).Name))[:])
33095                 chk(err)
33096         }
33097         {
33098                 x := (*(*(struct {
33099
33100                         // For players.
33101                         Name     string
33102                         IsPlayer bool
33103
33104                         ID AOID
33105
33106                         Pos
33107                         Rot [3]float32
33108
33109                         HP uint16
33110
33111                         // See (de)serialize.fmt.
33112                         Msgs []AOMsg
33113                 }))(obj)).IsPlayer
33114                 if x {
33115                         write8(w, 1)
33116                 } else {
33117                         write8(w, 0)
33118                 }
33119         }
33120         if err := pcall(func() {
33121                 ((*(*(struct {
33122
33123                         // For players.
33124                         Name     string
33125                         IsPlayer bool
33126
33127                         ID AOID
33128
33129                         Pos
33130                         Rot [3]float32
33131
33132                         HP uint16
33133
33134                         // See (de)serialize.fmt.
33135                         Msgs []AOMsg
33136                 }))(obj)).ID).serialize(w)
33137         }); err != nil {
33138                 if err == io.EOF {
33139                         chk(io.EOF)
33140                 }
33141                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
33142         }
33143         if err := pcall(func() {
33144                 ((*(*(struct {
33145
33146                         // For players.
33147                         Name     string
33148                         IsPlayer bool
33149
33150                         ID AOID
33151
33152                         Pos
33153                         Rot [3]float32
33154
33155                         HP uint16
33156
33157                         // See (de)serialize.fmt.
33158                         Msgs []AOMsg
33159                 }))(obj)).Pos).serialize(w)
33160         }); err != nil {
33161                 if err == io.EOF {
33162                         chk(io.EOF)
33163                 }
33164                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
33165         }
33166         for local390 := range (*(*(struct {
33167
33168                 // For players.
33169                 Name     string
33170                 IsPlayer bool
33171
33172                 ID AOID
33173
33174                 Pos
33175                 Rot [3]float32
33176
33177                 HP uint16
33178
33179                 // See (de)serialize.fmt.
33180                 Msgs []AOMsg
33181         }))(obj)).Rot {
33182                 {
33183                         x := ((*(*(struct {
33184
33185                                 // For players.
33186                                 Name     string
33187                                 IsPlayer bool
33188
33189                                 ID AOID
33190
33191                                 Pos
33192                                 Rot [3]float32
33193
33194                                 HP uint16
33195
33196                                 // See (de)serialize.fmt.
33197                                 Msgs []AOMsg
33198                         }))(obj)).Rot)[local390]
33199                         write32(w, math.Float32bits(x))
33200                 }
33201         }
33202         {
33203                 x := (*(*(struct {
33204
33205                         // For players.
33206                         Name     string
33207                         IsPlayer bool
33208
33209                         ID AOID
33210
33211                         Pos
33212                         Rot [3]float32
33213
33214                         HP uint16
33215
33216                         // See (de)serialize.fmt.
33217                         Msgs []AOMsg
33218                 }))(obj)).HP
33219                 write16(w, uint16(x))
33220         }
33221         {
33222                 x := (*(*(struct {
33223
33224                         // For players.
33225                         Name     string
33226                         IsPlayer bool
33227
33228                         ID AOID
33229
33230                         Pos
33231                         Rot [3]float32
33232
33233                         HP uint16
33234
33235                         // See (de)serialize.fmt.
33236                         Msgs []AOMsg
33237                 }))(obj)).Msgs
33238                 { // For AOInitData.Msgs.
33239                         if len(x) > math.MaxUint8 {
33240                                 chk(ErrTooLong)
33241                         }
33242                         write8(w, uint8(len(x)))
33243                         for _, msg := range x {
33244                                 var b bytes.Buffer
33245                                 chk(writeAOMsg(&b, msg))
33246                                 if b.Len() > math.MaxUint32 {
33247                                         chk(ErrTooLong)
33248                                 }
33249                                 write32(w, uint32(b.Len()))
33250                                 _, err := b.WriteTo(w)
33251                                 chk(err)
33252                         }
33253                 }
33254         }
33255 }
33256
33257 func (obj *AOInitData) deserialize(r io.Reader) {
33258         {
33259                 var local391 uint8
33260                 local392 := uint8(1)
33261                 {
33262                         p := &local391
33263                         *p = read8(r)
33264                 }
33265                 if local391 != local392 {
33266                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local391))
33267                 }
33268         }
33269         var local393 []uint8
33270         var local394 uint16
33271         {
33272                 p := &local394
33273                 *p = read16(r)
33274         }
33275         (local393) = make([]uint8, local394)
33276         {
33277                 _, err := io.ReadFull(r, (local393)[:])
33278                 chk(err)
33279         }
33280         ((*(*(struct {
33281
33282                 // For players.
33283                 Name     string
33284                 IsPlayer bool
33285
33286                 ID AOID
33287
33288                 Pos
33289                 Rot [3]float32
33290
33291                 HP uint16
33292
33293                 // See (de)serialize.fmt.
33294                 Msgs []AOMsg
33295         }))(obj)).Name) = string(local393)
33296         {
33297                 p := &(*(*(struct {
33298
33299                         // For players.
33300                         Name     string
33301                         IsPlayer bool
33302
33303                         ID AOID
33304
33305                         Pos
33306                         Rot [3]float32
33307
33308                         HP uint16
33309
33310                         // See (de)serialize.fmt.
33311                         Msgs []AOMsg
33312                 }))(obj)).IsPlayer
33313                 switch n := read8(r); n {
33314                 case 0:
33315                         *p = false
33316                 case 1:
33317                         *p = true
33318                 default:
33319                         chk(fmt.Errorf("invalid bool: %d", n))
33320                 }
33321         }
33322         if err := pcall(func() {
33323                 ((*(*(struct {
33324
33325                         // For players.
33326                         Name     string
33327                         IsPlayer bool
33328
33329                         ID AOID
33330
33331                         Pos
33332                         Rot [3]float32
33333
33334                         HP uint16
33335
33336                         // See (de)serialize.fmt.
33337                         Msgs []AOMsg
33338                 }))(obj)).ID).deserialize(r)
33339         }); err != nil {
33340                 if err == io.EOF {
33341                         chk(io.EOF)
33342                 }
33343                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
33344         }
33345         if err := pcall(func() {
33346                 ((*(*(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)).Pos).deserialize(r)
33362         }); err != nil {
33363                 if err == io.EOF {
33364                         chk(io.EOF)
33365                 }
33366                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
33367         }
33368         for local395 := range (*(*(struct {
33369
33370                 // For players.
33371                 Name     string
33372                 IsPlayer bool
33373
33374                 ID AOID
33375
33376                 Pos
33377                 Rot [3]float32
33378
33379                 HP uint16
33380
33381                 // See (de)serialize.fmt.
33382                 Msgs []AOMsg
33383         }))(obj)).Rot {
33384                 {
33385                         p := &((*(*(struct {
33386
33387                                 // For players.
33388                                 Name     string
33389                                 IsPlayer bool
33390
33391                                 ID AOID
33392
33393                                 Pos
33394                                 Rot [3]float32
33395
33396                                 HP uint16
33397
33398                                 // See (de)serialize.fmt.
33399                                 Msgs []AOMsg
33400                         }))(obj)).Rot)[local395]
33401                         *p = math.Float32frombits(read32(r))
33402                 }
33403         }
33404         {
33405                 p := &(*(*(struct {
33406
33407                         // For players.
33408                         Name     string
33409                         IsPlayer bool
33410
33411                         ID AOID
33412
33413                         Pos
33414                         Rot [3]float32
33415
33416                         HP uint16
33417
33418                         // See (de)serialize.fmt.
33419                         Msgs []AOMsg
33420                 }))(obj)).HP
33421                 *p = read16(r)
33422         }
33423         {
33424                 p := &(*(*(struct {
33425
33426                         // For players.
33427                         Name     string
33428                         IsPlayer bool
33429
33430                         ID AOID
33431
33432                         Pos
33433                         Rot [3]float32
33434
33435                         HP uint16
33436
33437                         // See (de)serialize.fmt.
33438                         Msgs []AOMsg
33439                 }))(obj)).Msgs
33440                 { // For AOInitData.Msgs.
33441                         *p = make([]AOMsg, read8(r))
33442                         for i := range *p {
33443                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33444                                 msg, err := readAOMsg(r)
33445                                 chk(err)
33446                                 (*p)[i] = msg
33447                                 if r.N > 0 {
33448                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33449                                 }
33450                         }
33451                 }
33452         }
33453 }
33454
33455 func (obj *ItemType) serialize(w io.Writer) {
33456         {
33457                 x := *(*(uint8))(obj)
33458                 write8(w, uint8(x))
33459         }
33460 }
33461
33462 func (obj *ItemType) deserialize(r io.Reader) {
33463         {
33464                 p := &*(*(uint8))(obj)
33465                 *p = read8(r)
33466         }
33467 }
33468
33469 func (obj *ToolCaps) serialize(w io.Writer) {
33470         if _ = (*(*(struct {
33471                 //mt:if _ = %s; false
33472                 NonNil bool
33473
33474                 AttackCooldown float32
33475                 MaxDropLvl     int16
33476
33477                 //mt:len32
33478                 GroupCaps []ToolGroupCap
33479
33480                 //mt:len32
33481                 DmgGroups []Group
33482
33483                 //mt:32tou16
33484                 PunchUses int32
33485         }))(obj)); false {
33486                 {
33487                         x := (*(*(struct {
33488                                 //mt:if _ = %s; false
33489                                 NonNil bool
33490
33491                                 AttackCooldown float32
33492                                 MaxDropLvl     int16
33493
33494                                 //mt:len32
33495                                 GroupCaps []ToolGroupCap
33496
33497                                 //mt:len32
33498                                 DmgGroups []Group
33499
33500                                 //mt:32tou16
33501                                 PunchUses int32
33502                         }))(obj)).NonNil
33503                         if x {
33504                                 write8(w, 1)
33505                         } else {
33506                                 write8(w, 0)
33507                         }
33508                 }
33509         }
33510         {
33511                 ow := w
33512                 w := new(bytes.Buffer)
33513                 /*
33514                    if r.N > 0 { (*(*(struct {
33515                         //mt:if _ = %s; false
33516                         NonNil  bool
33517
33518                         AttackCooldown  float32
33519                         MaxDropLvl      int16
33520
33521                         //mt:len32
33522                         GroupCaps       []ToolGroupCap
33523
33524                         //mt:len32
33525                         DmgGroups       []Group
33526
33527                         //mt:32tou16
33528                         PunchUses       int32
33529                    }))(obj)).NonNil = true}; /**/{
33530                         if (*(*(struct {
33531                                 //mt:if _ = %s; false
33532                                 NonNil bool
33533
33534                                 AttackCooldown float32
33535                                 MaxDropLvl     int16
33536
33537                                 //mt:len32
33538                                 GroupCaps []ToolGroupCap
33539
33540                                 //mt:len32
33541                                 DmgGroups []Group
33542
33543                                 //mt:32tou16
33544                                 PunchUses int32
33545                         }))(obj)).NonNil {
33546                                 {
33547                                         local396 := uint8(5)
33548                                         {
33549                                                 x := local396
33550                                                 write8(w, uint8(x))
33551                                         }
33552                                 }
33553                                 {
33554                                         x := (*(*(struct {
33555                                                 //mt:if _ = %s; false
33556                                                 NonNil bool
33557
33558                                                 AttackCooldown float32
33559                                                 MaxDropLvl     int16
33560
33561                                                 //mt:len32
33562                                                 GroupCaps []ToolGroupCap
33563
33564                                                 //mt:len32
33565                                                 DmgGroups []Group
33566
33567                                                 //mt:32tou16
33568                                                 PunchUses int32
33569                                         }))(obj)).AttackCooldown
33570                                         write32(w, math.Float32bits(x))
33571                                 }
33572                                 {
33573                                         x := (*(*(struct {
33574                                                 //mt:if _ = %s; false
33575                                                 NonNil bool
33576
33577                                                 AttackCooldown float32
33578                                                 MaxDropLvl     int16
33579
33580                                                 //mt:len32
33581                                                 GroupCaps []ToolGroupCap
33582
33583                                                 //mt:len32
33584                                                 DmgGroups []Group
33585
33586                                                 //mt:32tou16
33587                                                 PunchUses int32
33588                                         }))(obj)).MaxDropLvl
33589                                         write16(w, uint16(x))
33590                                 }
33591                                 if len(((*(*(struct {
33592                                         //mt:if _ = %s; false
33593                                         NonNil bool
33594
33595                                         AttackCooldown float32
33596                                         MaxDropLvl     int16
33597
33598                                         //mt:len32
33599                                         GroupCaps []ToolGroupCap
33600
33601                                         //mt:len32
33602                                         DmgGroups []Group
33603
33604                                         //mt:32tou16
33605                                         PunchUses int32
33606                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
33607                                         chk(ErrTooLong)
33608                                 }
33609                                 {
33610                                         x := uint32(len(((*(*(struct {
33611                                                 //mt:if _ = %s; false
33612                                                 NonNil bool
33613
33614                                                 AttackCooldown float32
33615                                                 MaxDropLvl     int16
33616
33617                                                 //mt:len32
33618                                                 GroupCaps []ToolGroupCap
33619
33620                                                 //mt:len32
33621                                                 DmgGroups []Group
33622
33623                                                 //mt:32tou16
33624                                                 PunchUses int32
33625                                         }))(obj)).GroupCaps)))
33626                                         write32(w, uint32(x))
33627                                 }
33628                                 for local397 := range (*(*(struct {
33629                                         //mt:if _ = %s; false
33630                                         NonNil bool
33631
33632                                         AttackCooldown float32
33633                                         MaxDropLvl     int16
33634
33635                                         //mt:len32
33636                                         GroupCaps []ToolGroupCap
33637
33638                                         //mt:len32
33639                                         DmgGroups []Group
33640
33641                                         //mt:32tou16
33642                                         PunchUses int32
33643                                 }))(obj)).GroupCaps {
33644                                         if err := pcall(func() {
33645                                                 (((*(*(struct {
33646                                                         //mt:if _ = %s; false
33647                                                         NonNil bool
33648
33649                                                         AttackCooldown float32
33650                                                         MaxDropLvl     int16
33651
33652                                                         //mt:len32
33653                                                         GroupCaps []ToolGroupCap
33654
33655                                                         //mt:len32
33656                                                         DmgGroups []Group
33657
33658                                                         //mt:32tou16
33659                                                         PunchUses int32
33660                                                 }))(obj)).GroupCaps)[local397]).serialize(w)
33661                                         }); err != nil {
33662                                                 if err == io.EOF {
33663                                                         chk(io.EOF)
33664                                                 }
33665                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolGroupCap", err))
33666                                         }
33667                                 }
33668                                 if len(((*(*(struct {
33669                                         //mt:if _ = %s; false
33670                                         NonNil bool
33671
33672                                         AttackCooldown float32
33673                                         MaxDropLvl     int16
33674
33675                                         //mt:len32
33676                                         GroupCaps []ToolGroupCap
33677
33678                                         //mt:len32
33679                                         DmgGroups []Group
33680
33681                                         //mt:32tou16
33682                                         PunchUses int32
33683                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
33684                                         chk(ErrTooLong)
33685                                 }
33686                                 {
33687                                         x := uint32(len(((*(*(struct {
33688                                                 //mt:if _ = %s; false
33689                                                 NonNil bool
33690
33691                                                 AttackCooldown float32
33692                                                 MaxDropLvl     int16
33693
33694                                                 //mt:len32
33695                                                 GroupCaps []ToolGroupCap
33696
33697                                                 //mt:len32
33698                                                 DmgGroups []Group
33699
33700                                                 //mt:32tou16
33701                                                 PunchUses int32
33702                                         }))(obj)).DmgGroups)))
33703                                         write32(w, uint32(x))
33704                                 }
33705                                 for local398 := range (*(*(struct {
33706                                         //mt:if _ = %s; false
33707                                         NonNil bool
33708
33709                                         AttackCooldown float32
33710                                         MaxDropLvl     int16
33711
33712                                         //mt:len32
33713                                         GroupCaps []ToolGroupCap
33714
33715                                         //mt:len32
33716                                         DmgGroups []Group
33717
33718                                         //mt:32tou16
33719                                         PunchUses int32
33720                                 }))(obj)).DmgGroups {
33721                                         if err := pcall(func() {
33722                                                 (((*(*(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)).DmgGroups)[local398]).serialize(w)
33738                                         }); err != nil {
33739                                                 if err == io.EOF {
33740                                                         chk(io.EOF)
33741                                                 }
33742                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
33743                                         }
33744                                 }
33745                                 {
33746                                         x := uint16((*(*(struct {
33747                                                 //mt:if _ = %s; false
33748                                                 NonNil bool
33749
33750                                                 AttackCooldown float32
33751                                                 MaxDropLvl     int16
33752
33753                                                 //mt:len32
33754                                                 GroupCaps []ToolGroupCap
33755
33756                                                 //mt:len32
33757                                                 DmgGroups []Group
33758
33759                                                 //mt:32tou16
33760                                                 PunchUses int32
33761                                         }))(obj)).PunchUses)
33762                                         write16(w, uint16(x))
33763                                 }
33764                         }
33765                 }
33766                 {
33767                         buf := w
33768                         w := ow
33769                         if len((buf.Bytes())) > math.MaxUint16 {
33770                                 chk(ErrTooLong)
33771                         }
33772                         {
33773                                 x := uint16(len((buf.Bytes())))
33774                                 write16(w, uint16(x))
33775                         }
33776                         {
33777                                 _, err := w.Write((buf.Bytes())[:])
33778                                 chk(err)
33779                         }
33780                 }
33781         }
33782 }
33783
33784 func (obj *ToolCaps) deserialize(r io.Reader) {
33785         if _ = (*(*(struct {
33786                 //mt:if _ = %s; false
33787                 NonNil bool
33788
33789                 AttackCooldown float32
33790                 MaxDropLvl     int16
33791
33792                 //mt:len32
33793                 GroupCaps []ToolGroupCap
33794
33795                 //mt:len32
33796                 DmgGroups []Group
33797
33798                 //mt:32tou16
33799                 PunchUses int32
33800         }))(obj)); false {
33801                 {
33802                         p := &(*(*(struct {
33803                                 //mt:if _ = %s; false
33804                                 NonNil bool
33805
33806                                 AttackCooldown float32
33807                                 MaxDropLvl     int16
33808
33809                                 //mt:len32
33810                                 GroupCaps []ToolGroupCap
33811
33812                                 //mt:len32
33813                                 DmgGroups []Group
33814
33815                                 //mt:32tou16
33816                                 PunchUses int32
33817                         }))(obj)).NonNil
33818                         switch n := read8(r); n {
33819                         case 0:
33820                                 *p = false
33821                         case 1:
33822                                 *p = true
33823                         default:
33824                                 chk(fmt.Errorf("invalid bool: %d", n))
33825                         }
33826                 }
33827         }
33828         {
33829                 var n uint16
33830                 {
33831                         p := &n
33832                         *p = read16(r)
33833                 }
33834                 r := &io.LimitedReader{R: r, N: int64(n)}
33835                 if r.N > 0 {
33836                         (*(*(struct {
33837                                 //mt:if _ = %s; false
33838                                 NonNil bool
33839
33840                                 AttackCooldown float32
33841                                 MaxDropLvl     int16
33842
33843                                 //mt:len32
33844                                 GroupCaps []ToolGroupCap
33845
33846                                 //mt:len32
33847                                 DmgGroups []Group
33848
33849                                 //mt:32tou16
33850                                 PunchUses int32
33851                         }))(obj)).NonNil = true
33852                 } /**/
33853                 {
33854                         if (*(*(struct {
33855                                 //mt:if _ = %s; false
33856                                 NonNil bool
33857
33858                                 AttackCooldown float32
33859                                 MaxDropLvl     int16
33860
33861                                 //mt:len32
33862                                 GroupCaps []ToolGroupCap
33863
33864                                 //mt:len32
33865                                 DmgGroups []Group
33866
33867                                 //mt:32tou16
33868                                 PunchUses int32
33869                         }))(obj)).NonNil {
33870                                 {
33871                                         var local399 uint8
33872                                         local400 := uint8(5)
33873                                         {
33874                                                 p := &local399
33875                                                 *p = read8(r)
33876                                         }
33877                                         if local399 != local400 {
33878                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local399))
33879                                         }
33880                                 }
33881                                 {
33882                                         p := &(*(*(struct {
33883                                                 //mt:if _ = %s; false
33884                                                 NonNil bool
33885
33886                                                 AttackCooldown float32
33887                                                 MaxDropLvl     int16
33888
33889                                                 //mt:len32
33890                                                 GroupCaps []ToolGroupCap
33891
33892                                                 //mt:len32
33893                                                 DmgGroups []Group
33894
33895                                                 //mt:32tou16
33896                                                 PunchUses int32
33897                                         }))(obj)).AttackCooldown
33898                                         *p = math.Float32frombits(read32(r))
33899                                 }
33900                                 {
33901                                         p := &(*(*(struct {
33902                                                 //mt:if _ = %s; false
33903                                                 NonNil bool
33904
33905                                                 AttackCooldown float32
33906                                                 MaxDropLvl     int16
33907
33908                                                 //mt:len32
33909                                                 GroupCaps []ToolGroupCap
33910
33911                                                 //mt:len32
33912                                                 DmgGroups []Group
33913
33914                                                 //mt:32tou16
33915                                                 PunchUses int32
33916                                         }))(obj)).MaxDropLvl
33917                                         *p = int16(read16(r))
33918                                 }
33919                                 var local401 uint32
33920                                 {
33921                                         p := &local401
33922                                         *p = read32(r)
33923                                 }
33924                                 ((*(*(struct {
33925                                         //mt:if _ = %s; false
33926                                         NonNil bool
33927
33928                                         AttackCooldown float32
33929                                         MaxDropLvl     int16
33930
33931                                         //mt:len32
33932                                         GroupCaps []ToolGroupCap
33933
33934                                         //mt:len32
33935                                         DmgGroups []Group
33936
33937                                         //mt:32tou16
33938                                         PunchUses int32
33939                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local401)
33940                                 for local402 := range (*(*(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)).GroupCaps {
33956                                         if err := pcall(func() {
33957                                                 (((*(*(struct {
33958                                                         //mt:if _ = %s; false
33959                                                         NonNil bool
33960
33961                                                         AttackCooldown float32
33962                                                         MaxDropLvl     int16
33963
33964                                                         //mt:len32
33965                                                         GroupCaps []ToolGroupCap
33966
33967                                                         //mt:len32
33968                                                         DmgGroups []Group
33969
33970                                                         //mt:32tou16
33971                                                         PunchUses int32
33972                                                 }))(obj)).GroupCaps)[local402]).deserialize(r)
33973                                         }); err != nil {
33974                                                 if err == io.EOF {
33975                                                         chk(io.EOF)
33976                                                 }
33977                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolGroupCap", err))
33978                                         }
33979                                 }
33980                                 var local403 uint32
33981                                 {
33982                                         p := &local403
33983                                         *p = read32(r)
33984                                 }
33985                                 ((*(*(struct {
33986                                         //mt:if _ = %s; false
33987                                         NonNil bool
33988
33989                                         AttackCooldown float32
33990                                         MaxDropLvl     int16
33991
33992                                         //mt:len32
33993                                         GroupCaps []ToolGroupCap
33994
33995                                         //mt:len32
33996                                         DmgGroups []Group
33997
33998                                         //mt:32tou16
33999                                         PunchUses int32
34000                                 }))(obj)).DmgGroups) = make([]Group, local403)
34001                                 for local404 := range (*(*(struct {
34002                                         //mt:if _ = %s; false
34003                                         NonNil bool
34004
34005                                         AttackCooldown float32
34006                                         MaxDropLvl     int16
34007
34008                                         //mt:len32
34009                                         GroupCaps []ToolGroupCap
34010
34011                                         //mt:len32
34012                                         DmgGroups []Group
34013
34014                                         //mt:32tou16
34015                                         PunchUses int32
34016                                 }))(obj)).DmgGroups {
34017                                         if err := pcall(func() {
34018                                                 (((*(*(struct {
34019                                                         //mt:if _ = %s; false
34020                                                         NonNil bool
34021
34022                                                         AttackCooldown float32
34023                                                         MaxDropLvl     int16
34024
34025                                                         //mt:len32
34026                                                         GroupCaps []ToolGroupCap
34027
34028                                                         //mt:len32
34029                                                         DmgGroups []Group
34030
34031                                                         //mt:32tou16
34032                                                         PunchUses int32
34033                                                 }))(obj)).DmgGroups)[local404]).deserialize(r)
34034                                         }); err != nil {
34035                                                 if err == io.EOF {
34036                                                         chk(io.EOF)
34037                                                 }
34038                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
34039                                         }
34040                                 }
34041                                 var local405 uint16
34042                                 {
34043                                         p := &local405
34044                                         *p = read16(r)
34045                                 }
34046                                 (*(*(struct {
34047                                         //mt:if _ = %s; false
34048                                         NonNil bool
34049
34050                                         AttackCooldown float32
34051                                         MaxDropLvl     int16
34052
34053                                         //mt:len32
34054                                         GroupCaps []ToolGroupCap
34055
34056                                         //mt:len32
34057                                         DmgGroups []Group
34058
34059                                         //mt:32tou16
34060                                         PunchUses int32
34061                                 }))(obj)).PunchUses = int32(local405)
34062                         }
34063                 }
34064                 if r.N > 0 {
34065                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34066                 }
34067         }
34068 }
34069
34070 func (obj *AnimType) serialize(w io.Writer) {
34071         {
34072                 x := *(*(uint8))(obj)
34073                 write8(w, uint8(x))
34074         }
34075 }
34076
34077 func (obj *AnimType) deserialize(r io.Reader) {
34078         {
34079                 p := &*(*(uint8))(obj)
34080                 *p = read8(r)
34081         }
34082 }
34083
34084 func (obj *HUDType) serialize(w io.Writer) {
34085         {
34086                 x := *(*(uint8))(obj)
34087                 write8(w, uint8(x))
34088         }
34089 }
34090
34091 func (obj *HUDType) deserialize(r io.Reader) {
34092         {
34093                 p := &*(*(uint8))(obj)
34094                 *p = read8(r)
34095         }
34096 }
34097
34098 func (obj *Box) serialize(w io.Writer) {
34099         for local406 := range *(*([2]Vec))(obj) {
34100                 if err := pcall(func() {
34101                         ((*(*([2]Vec))(obj))[local406]).serialize(w)
34102                 }); err != nil {
34103                         if err == io.EOF {
34104                                 chk(io.EOF)
34105                         }
34106                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
34107                 }
34108         }
34109 }
34110
34111 func (obj *Box) deserialize(r io.Reader) {
34112         for local407 := range *(*([2]Vec))(obj) {
34113                 if err := pcall(func() {
34114                         ((*(*([2]Vec))(obj))[local407]).deserialize(r)
34115                 }); err != nil {
34116                         if err == io.EOF {
34117                                 chk(io.EOF)
34118                         }
34119                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
34120                 }
34121         }
34122 }
34123
34124 func (obj *TileFlags) serialize(w io.Writer) {
34125         {
34126                 x := *(*(uint16))(obj)
34127                 write16(w, uint16(x))
34128         }
34129 }
34130
34131 func (obj *TileFlags) deserialize(r io.Reader) {
34132         {
34133                 p := &*(*(uint16))(obj)
34134                 *p = read16(r)
34135         }
34136 }
34137
34138 func (obj *AlignType) serialize(w io.Writer) {
34139         {
34140                 x := *(*(uint8))(obj)
34141                 write8(w, uint8(x))
34142         }
34143 }
34144
34145 func (obj *AlignType) deserialize(r io.Reader) {
34146         {
34147                 p := &*(*(uint8))(obj)
34148                 *p = read8(r)
34149         }
34150 }
34151
34152 func (obj *NodeBoxType) serialize(w io.Writer) {
34153         {
34154                 x := *(*(uint8))(obj)
34155                 write8(w, uint8(x))
34156         }
34157 }
34158
34159 func (obj *NodeBoxType) deserialize(r io.Reader) {
34160         {
34161                 p := &*(*(uint8))(obj)
34162                 *p = read8(r)
34163         }
34164 }
34165
34166 func (obj *DirBoxes) serialize(w io.Writer) {
34167         if len(((*(*(struct {
34168                 Top, Bot                 []Box
34169                 Front, Left, Back, Right []Box
34170         }))(obj)).Top)) > math.MaxUint16 {
34171                 chk(ErrTooLong)
34172         }
34173         {
34174                 x := uint16(len(((*(*(struct {
34175                         Top, Bot                 []Box
34176                         Front, Left, Back, Right []Box
34177                 }))(obj)).Top)))
34178                 write16(w, uint16(x))
34179         }
34180         for local408 := range (*(*(struct {
34181                 Top, Bot                 []Box
34182                 Front, Left, Back, Right []Box
34183         }))(obj)).Top {
34184                 if err := pcall(func() {
34185                         (((*(*(struct {
34186                                 Top, Bot                 []Box
34187                                 Front, Left, Back, Right []Box
34188                         }))(obj)).Top)[local408]).serialize(w)
34189                 }); err != nil {
34190                         if err == io.EOF {
34191                                 chk(io.EOF)
34192                         }
34193                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34194                 }
34195         }
34196         if len(((*(*(struct {
34197                 Top, Bot                 []Box
34198                 Front, Left, Back, Right []Box
34199         }))(obj)).Bot)) > math.MaxUint16 {
34200                 chk(ErrTooLong)
34201         }
34202         {
34203                 x := uint16(len(((*(*(struct {
34204                         Top, Bot                 []Box
34205                         Front, Left, Back, Right []Box
34206                 }))(obj)).Bot)))
34207                 write16(w, uint16(x))
34208         }
34209         for local409 := range (*(*(struct {
34210                 Top, Bot                 []Box
34211                 Front, Left, Back, Right []Box
34212         }))(obj)).Bot {
34213                 if err := pcall(func() {
34214                         (((*(*(struct {
34215                                 Top, Bot                 []Box
34216                                 Front, Left, Back, Right []Box
34217                         }))(obj)).Bot)[local409]).serialize(w)
34218                 }); err != nil {
34219                         if err == io.EOF {
34220                                 chk(io.EOF)
34221                         }
34222                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34223                 }
34224         }
34225         if len(((*(*(struct {
34226                 Top, Bot                 []Box
34227                 Front, Left, Back, Right []Box
34228         }))(obj)).Front)) > math.MaxUint16 {
34229                 chk(ErrTooLong)
34230         }
34231         {
34232                 x := uint16(len(((*(*(struct {
34233                         Top, Bot                 []Box
34234                         Front, Left, Back, Right []Box
34235                 }))(obj)).Front)))
34236                 write16(w, uint16(x))
34237         }
34238         for local410 := range (*(*(struct {
34239                 Top, Bot                 []Box
34240                 Front, Left, Back, Right []Box
34241         }))(obj)).Front {
34242                 if err := pcall(func() {
34243                         (((*(*(struct {
34244                                 Top, Bot                 []Box
34245                                 Front, Left, Back, Right []Box
34246                         }))(obj)).Front)[local410]).serialize(w)
34247                 }); err != nil {
34248                         if err == io.EOF {
34249                                 chk(io.EOF)
34250                         }
34251                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34252                 }
34253         }
34254         if len(((*(*(struct {
34255                 Top, Bot                 []Box
34256                 Front, Left, Back, Right []Box
34257         }))(obj)).Left)) > math.MaxUint16 {
34258                 chk(ErrTooLong)
34259         }
34260         {
34261                 x := uint16(len(((*(*(struct {
34262                         Top, Bot                 []Box
34263                         Front, Left, Back, Right []Box
34264                 }))(obj)).Left)))
34265                 write16(w, uint16(x))
34266         }
34267         for local411 := range (*(*(struct {
34268                 Top, Bot                 []Box
34269                 Front, Left, Back, Right []Box
34270         }))(obj)).Left {
34271                 if err := pcall(func() {
34272                         (((*(*(struct {
34273                                 Top, Bot                 []Box
34274                                 Front, Left, Back, Right []Box
34275                         }))(obj)).Left)[local411]).serialize(w)
34276                 }); err != nil {
34277                         if err == io.EOF {
34278                                 chk(io.EOF)
34279                         }
34280                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34281                 }
34282         }
34283         if len(((*(*(struct {
34284                 Top, Bot                 []Box
34285                 Front, Left, Back, Right []Box
34286         }))(obj)).Back)) > math.MaxUint16 {
34287                 chk(ErrTooLong)
34288         }
34289         {
34290                 x := uint16(len(((*(*(struct {
34291                         Top, Bot                 []Box
34292                         Front, Left, Back, Right []Box
34293                 }))(obj)).Back)))
34294                 write16(w, uint16(x))
34295         }
34296         for local412 := range (*(*(struct {
34297                 Top, Bot                 []Box
34298                 Front, Left, Back, Right []Box
34299         }))(obj)).Back {
34300                 if err := pcall(func() {
34301                         (((*(*(struct {
34302                                 Top, Bot                 []Box
34303                                 Front, Left, Back, Right []Box
34304                         }))(obj)).Back)[local412]).serialize(w)
34305                 }); err != nil {
34306                         if err == io.EOF {
34307                                 chk(io.EOF)
34308                         }
34309                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34310                 }
34311         }
34312         if len(((*(*(struct {
34313                 Top, Bot                 []Box
34314                 Front, Left, Back, Right []Box
34315         }))(obj)).Right)) > math.MaxUint16 {
34316                 chk(ErrTooLong)
34317         }
34318         {
34319                 x := uint16(len(((*(*(struct {
34320                         Top, Bot                 []Box
34321                         Front, Left, Back, Right []Box
34322                 }))(obj)).Right)))
34323                 write16(w, uint16(x))
34324         }
34325         for local413 := range (*(*(struct {
34326                 Top, Bot                 []Box
34327                 Front, Left, Back, Right []Box
34328         }))(obj)).Right {
34329                 if err := pcall(func() {
34330                         (((*(*(struct {
34331                                 Top, Bot                 []Box
34332                                 Front, Left, Back, Right []Box
34333                         }))(obj)).Right)[local413]).serialize(w)
34334                 }); err != nil {
34335                         if err == io.EOF {
34336                                 chk(io.EOF)
34337                         }
34338                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34339                 }
34340         }
34341 }
34342
34343 func (obj *DirBoxes) deserialize(r io.Reader) {
34344         var local414 uint16
34345         {
34346                 p := &local414
34347                 *p = read16(r)
34348         }
34349         ((*(*(struct {
34350                 Top, Bot                 []Box
34351                 Front, Left, Back, Right []Box
34352         }))(obj)).Top) = make([]Box, local414)
34353         for local415 := range (*(*(struct {
34354                 Top, Bot                 []Box
34355                 Front, Left, Back, Right []Box
34356         }))(obj)).Top {
34357                 if err := pcall(func() {
34358                         (((*(*(struct {
34359                                 Top, Bot                 []Box
34360                                 Front, Left, Back, Right []Box
34361                         }))(obj)).Top)[local415]).deserialize(r)
34362                 }); err != nil {
34363                         if err == io.EOF {
34364                                 chk(io.EOF)
34365                         }
34366                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34367                 }
34368         }
34369         var local416 uint16
34370         {
34371                 p := &local416
34372                 *p = read16(r)
34373         }
34374         ((*(*(struct {
34375                 Top, Bot                 []Box
34376                 Front, Left, Back, Right []Box
34377         }))(obj)).Bot) = make([]Box, local416)
34378         for local417 := range (*(*(struct {
34379                 Top, Bot                 []Box
34380                 Front, Left, Back, Right []Box
34381         }))(obj)).Bot {
34382                 if err := pcall(func() {
34383                         (((*(*(struct {
34384                                 Top, Bot                 []Box
34385                                 Front, Left, Back, Right []Box
34386                         }))(obj)).Bot)[local417]).deserialize(r)
34387                 }); err != nil {
34388                         if err == io.EOF {
34389                                 chk(io.EOF)
34390                         }
34391                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34392                 }
34393         }
34394         var local418 uint16
34395         {
34396                 p := &local418
34397                 *p = read16(r)
34398         }
34399         ((*(*(struct {
34400                 Top, Bot                 []Box
34401                 Front, Left, Back, Right []Box
34402         }))(obj)).Front) = make([]Box, local418)
34403         for local419 := range (*(*(struct {
34404                 Top, Bot                 []Box
34405                 Front, Left, Back, Right []Box
34406         }))(obj)).Front {
34407                 if err := pcall(func() {
34408                         (((*(*(struct {
34409                                 Top, Bot                 []Box
34410                                 Front, Left, Back, Right []Box
34411                         }))(obj)).Front)[local419]).deserialize(r)
34412                 }); err != nil {
34413                         if err == io.EOF {
34414                                 chk(io.EOF)
34415                         }
34416                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34417                 }
34418         }
34419         var local420 uint16
34420         {
34421                 p := &local420
34422                 *p = read16(r)
34423         }
34424         ((*(*(struct {
34425                 Top, Bot                 []Box
34426                 Front, Left, Back, Right []Box
34427         }))(obj)).Left) = make([]Box, local420)
34428         for local421 := range (*(*(struct {
34429                 Top, Bot                 []Box
34430                 Front, Left, Back, Right []Box
34431         }))(obj)).Left {
34432                 if err := pcall(func() {
34433                         (((*(*(struct {
34434                                 Top, Bot                 []Box
34435                                 Front, Left, Back, Right []Box
34436                         }))(obj)).Left)[local421]).deserialize(r)
34437                 }); err != nil {
34438                         if err == io.EOF {
34439                                 chk(io.EOF)
34440                         }
34441                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34442                 }
34443         }
34444         var local422 uint16
34445         {
34446                 p := &local422
34447                 *p = read16(r)
34448         }
34449         ((*(*(struct {
34450                 Top, Bot                 []Box
34451                 Front, Left, Back, Right []Box
34452         }))(obj)).Back) = make([]Box, local422)
34453         for local423 := range (*(*(struct {
34454                 Top, Bot                 []Box
34455                 Front, Left, Back, Right []Box
34456         }))(obj)).Back {
34457                 if err := pcall(func() {
34458                         (((*(*(struct {
34459                                 Top, Bot                 []Box
34460                                 Front, Left, Back, Right []Box
34461                         }))(obj)).Back)[local423]).deserialize(r)
34462                 }); err != nil {
34463                         if err == io.EOF {
34464                                 chk(io.EOF)
34465                         }
34466                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34467                 }
34468         }
34469         var local424 uint16
34470         {
34471                 p := &local424
34472                 *p = read16(r)
34473         }
34474         ((*(*(struct {
34475                 Top, Bot                 []Box
34476                 Front, Left, Back, Right []Box
34477         }))(obj)).Right) = make([]Box, local424)
34478         for local425 := range (*(*(struct {
34479                 Top, Bot                 []Box
34480                 Front, Left, Back, Right []Box
34481         }))(obj)).Right {
34482                 if err := pcall(func() {
34483                         (((*(*(struct {
34484                                 Top, Bot                 []Box
34485                                 Front, Left, Back, Right []Box
34486                         }))(obj)).Right)[local425]).deserialize(r)
34487                 }); err != nil {
34488                         if err == io.EOF {
34489                                 chk(io.EOF)
34490                         }
34491                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34492                 }
34493         }
34494 }
34495
34496 func (obj *ToolGroupCap) serialize(w io.Writer) {
34497         if len(([]byte((*(*(struct {
34498                 Name string
34499
34500                 //mt:32to16
34501                 Uses int32
34502
34503                 MaxLvl int16
34504
34505                 //mt:len32
34506                 Times []DigTime
34507         }))(obj)).Name))) > math.MaxUint16 {
34508                 chk(ErrTooLong)
34509         }
34510         {
34511                 x := uint16(len(([]byte((*(*(struct {
34512                         Name string
34513
34514                         //mt:32to16
34515                         Uses int32
34516
34517                         MaxLvl int16
34518
34519                         //mt:len32
34520                         Times []DigTime
34521                 }))(obj)).Name))))
34522                 write16(w, uint16(x))
34523         }
34524         {
34525                 _, err := w.Write(([]byte((*(*(struct {
34526                         Name string
34527
34528                         //mt:32to16
34529                         Uses int32
34530
34531                         MaxLvl int16
34532
34533                         //mt:len32
34534                         Times []DigTime
34535                 }))(obj)).Name))[:])
34536                 chk(err)
34537         }
34538         {
34539                 x := int16((*(*(struct {
34540                         Name string
34541
34542                         //mt:32to16
34543                         Uses int32
34544
34545                         MaxLvl int16
34546
34547                         //mt:len32
34548                         Times []DigTime
34549                 }))(obj)).Uses)
34550                 write16(w, uint16(x))
34551         }
34552         {
34553                 x := (*(*(struct {
34554                         Name string
34555
34556                         //mt:32to16
34557                         Uses int32
34558
34559                         MaxLvl int16
34560
34561                         //mt:len32
34562                         Times []DigTime
34563                 }))(obj)).MaxLvl
34564                 write16(w, uint16(x))
34565         }
34566         if len(((*(*(struct {
34567                 Name string
34568
34569                 //mt:32to16
34570                 Uses int32
34571
34572                 MaxLvl int16
34573
34574                 //mt:len32
34575                 Times []DigTime
34576         }))(obj)).Times)) > math.MaxUint32 {
34577                 chk(ErrTooLong)
34578         }
34579         {
34580                 x := uint32(len(((*(*(struct {
34581                         Name string
34582
34583                         //mt:32to16
34584                         Uses int32
34585
34586                         MaxLvl int16
34587
34588                         //mt:len32
34589                         Times []DigTime
34590                 }))(obj)).Times)))
34591                 write32(w, uint32(x))
34592         }
34593         for local426 := range (*(*(struct {
34594                 Name string
34595
34596                 //mt:32to16
34597                 Uses int32
34598
34599                 MaxLvl int16
34600
34601                 //mt:len32
34602                 Times []DigTime
34603         }))(obj)).Times {
34604                 if err := pcall(func() {
34605                         (((*(*(struct {
34606                                 Name string
34607
34608                                 //mt:32to16
34609                                 Uses int32
34610
34611                                 MaxLvl int16
34612
34613                                 //mt:len32
34614                                 Times []DigTime
34615                         }))(obj)).Times)[local426]).serialize(w)
34616                 }); err != nil {
34617                         if err == io.EOF {
34618                                 chk(io.EOF)
34619                         }
34620                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DigTime", err))
34621                 }
34622         }
34623 }
34624
34625 func (obj *ToolGroupCap) deserialize(r io.Reader) {
34626         var local427 []uint8
34627         var local428 uint16
34628         {
34629                 p := &local428
34630                 *p = read16(r)
34631         }
34632         (local427) = make([]uint8, local428)
34633         {
34634                 _, err := io.ReadFull(r, (local427)[:])
34635                 chk(err)
34636         }
34637         ((*(*(struct {
34638                 Name string
34639
34640                 //mt:32to16
34641                 Uses int32
34642
34643                 MaxLvl int16
34644
34645                 //mt:len32
34646                 Times []DigTime
34647         }))(obj)).Name) = string(local427)
34648         var local429 int16
34649         {
34650                 p := &local429
34651                 *p = int16(read16(r))
34652         }
34653         (*(*(struct {
34654                 Name string
34655
34656                 //mt:32to16
34657                 Uses int32
34658
34659                 MaxLvl int16
34660
34661                 //mt:len32
34662                 Times []DigTime
34663         }))(obj)).Uses = int32(local429)
34664         {
34665                 p := &(*(*(struct {
34666                         Name string
34667
34668                         //mt:32to16
34669                         Uses int32
34670
34671                         MaxLvl int16
34672
34673                         //mt:len32
34674                         Times []DigTime
34675                 }))(obj)).MaxLvl
34676                 *p = int16(read16(r))
34677         }
34678         var local430 uint32
34679         {
34680                 p := &local430
34681                 *p = read32(r)
34682         }
34683         ((*(*(struct {
34684                 Name string
34685
34686                 //mt:32to16
34687                 Uses int32
34688
34689                 MaxLvl int16
34690
34691                 //mt:len32
34692                 Times []DigTime
34693         }))(obj)).Times) = make([]DigTime, local430)
34694         for local431 := range (*(*(struct {
34695                 Name string
34696
34697                 //mt:32to16
34698                 Uses int32
34699
34700                 MaxLvl int16
34701
34702                 //mt:len32
34703                 Times []DigTime
34704         }))(obj)).Times {
34705                 if err := pcall(func() {
34706                         (((*(*(struct {
34707                                 Name string
34708
34709                                 //mt:32to16
34710                                 Uses int32
34711
34712                                 MaxLvl int16
34713
34714                                 //mt:len32
34715                                 Times []DigTime
34716                         }))(obj)).Times)[local431]).deserialize(r)
34717                 }); err != nil {
34718                         if err == io.EOF {
34719                                 chk(io.EOF)
34720                         }
34721                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DigTime", err))
34722                 }
34723         }
34724 }
34725
34726 func (obj *DigTime) serialize(w io.Writer) {
34727         {
34728                 x := (*(*(struct {
34729                         Rating int16
34730                         Time   float32
34731                 }))(obj)).Rating
34732                 write16(w, uint16(x))
34733         }
34734         {
34735                 x := (*(*(struct {
34736                         Rating int16
34737                         Time   float32
34738                 }))(obj)).Time
34739                 write32(w, math.Float32bits(x))
34740         }
34741 }
34742
34743 func (obj *DigTime) deserialize(r io.Reader) {
34744         {
34745                 p := &(*(*(struct {
34746                         Rating int16
34747                         Time   float32
34748                 }))(obj)).Rating
34749                 *p = int16(read16(r))
34750         }
34751         {
34752                 p := &(*(*(struct {
34753                         Rating int16
34754                         Time   float32
34755                 }))(obj)).Time
34756                 *p = math.Float32frombits(read32(r))
34757         }
34758 }