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
  24 func write16(w io.Writer, x uint16) {
  25         buf := make([]byte, 2)
  26         be.PutUint16(buf, x)
  27         _, err := w.Write(buf)
  28         chk(err)
  29 }
  30
  31 func write32(w io.Writer, x uint32) {
  32         buf := make([]byte, 4)
  33         be.PutUint32(buf, x)
  34         _, err := w.Write(buf)
  35         chk(err)
  36 }
  37
  38 func write64(w io.Writer, x uint64) {
  39         buf := make([]byte, 8)
  40         be.PutUint64(buf, x)
  41         _, err := w.Write(buf)
  42         chk(err)
  43 }
  44
  45 func readBuf(r io.Reader, n int) []byte {
  46         buf := make([]byte, n)
  47         _, err := io.ReadFull(r, buf)
  48         chk(err)
  49         return buf
  50 }
  51
  52 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  53 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  54 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  55 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  56
  57 func (obj *ToSrvNil) serialize(w io.Writer) {
  58 }
  59
  60 func (obj *ToSrvNil) deserialize(r io.Reader) {
  61 }
  62
  63 func (obj *ToSrvInit) serialize(w io.Writer) {
  64         {
  65                 x := (*(*(struct {
  66                         SerializeVer             uint8
  67                         SupportedCompression     CompressionModes
  68                         MinProtoVer, MaxProtoVer uint16
  69                         PlayerName               string
  70
  71                         //mt:opt
  72                         SendFullItemMeta bool
  73                 }))(obj)).SerializeVer
  74                 write8(w, uint8(x))
  75         }
  76         if err := pcall(func() {
  77                 ((*(*(struct {
  78                         SerializeVer             uint8
  79                         SupportedCompression     CompressionModes
  80                         MinProtoVer, MaxProtoVer uint16
  81                         PlayerName               string
  82
  83                         //mt:opt
  84                         SendFullItemMeta bool
  85                 }))(obj)).SupportedCompression).serialize(w)
  86         }); err != nil {
  87                 if err == io.EOF {
  88                         chk(io.EOF)
  89                 }
  90                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
  91         }
  92         {
  93                 x := (*(*(struct {
  94                         SerializeVer             uint8
  95                         SupportedCompression     CompressionModes
  96                         MinProtoVer, MaxProtoVer uint16
  97                         PlayerName               string
  98
  99                         //mt:opt
 100                         SendFullItemMeta bool
 101                 }))(obj)).MinProtoVer
 102                 write16(w, uint16(x))
 103         }
 104         {
 105                 x := (*(*(struct {
 106                         SerializeVer             uint8
 107                         SupportedCompression     CompressionModes
 108                         MinProtoVer, MaxProtoVer uint16
 109                         PlayerName               string
 110
 111                         //mt:opt
 112                         SendFullItemMeta bool
 113                 }))(obj)).MaxProtoVer
 114                 write16(w, uint16(x))
 115         }
 116         if len(([]byte((*(*(struct {
 117                 SerializeVer             uint8
 118                 SupportedCompression     CompressionModes
 119                 MinProtoVer, MaxProtoVer uint16
 120                 PlayerName               string
 121
 122                 //mt:opt
 123                 SendFullItemMeta bool
 124         }))(obj)).PlayerName))) > math.MaxUint16 {
 125                 chk(ErrTooLong)
 126         }
 127         {
 128                 x := uint16(len(([]byte((*(*(struct {
 129                         SerializeVer             uint8
 130                         SupportedCompression     CompressionModes
 131                         MinProtoVer, MaxProtoVer uint16
 132                         PlayerName               string
 133
 134                         //mt:opt
 135                         SendFullItemMeta bool
 136                 }))(obj)).PlayerName))))
 137                 write16(w, uint16(x))
 138         }
 139         {
 140                 _, err := w.Write(([]byte((*(*(struct {
 141                         SerializeVer             uint8
 142                         SupportedCompression     CompressionModes
 143                         MinProtoVer, MaxProtoVer uint16
 144                         PlayerName               string
 145
 146                         //mt:opt
 147                         SendFullItemMeta bool
 148                 }))(obj)).PlayerName))[:])
 149                 chk(err)
 150         }
 151         if err := pcall(func() {
 152                 {
 153                         x := (*(*(struct {
 154                                 SerializeVer             uint8
 155                                 SupportedCompression     CompressionModes
 156                                 MinProtoVer, MaxProtoVer uint16
 157                                 PlayerName               string
 158
 159                                 //mt:opt
 160                                 SendFullItemMeta bool
 161                         }))(obj)).SendFullItemMeta
 162                         if x {
 163                                 write8(w, 1)
 164                         } else {
 165                                 write8(w, 0)
 166                         }
 167
 168                 }
 169         }); err != nil && err != io.EOF {
 170                 chk(err)
 171         }
 172 }
 173
 174 func (obj *ToSrvInit) deserialize(r io.Reader) {
 175         {
 176                 p := &(*(*(struct {
 177                         SerializeVer             uint8
 178                         SupportedCompression     CompressionModes
 179                         MinProtoVer, MaxProtoVer uint16
 180                         PlayerName               string
 181
 182                         //mt:opt
 183                         SendFullItemMeta bool
 184                 }))(obj)).SerializeVer
 185                 *p = read8(r)
 186         }
 187         if err := pcall(func() {
 188                 ((*(*(struct {
 189                         SerializeVer             uint8
 190                         SupportedCompression     CompressionModes
 191                         MinProtoVer, MaxProtoVer uint16
 192                         PlayerName               string
 193
 194                         //mt:opt
 195                         SendFullItemMeta bool
 196                 }))(obj)).SupportedCompression).deserialize(r)
 197         }); err != nil {
 198                 if err == io.EOF {
 199                         chk(io.EOF)
 200                 }
 201                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
 202         }
 203         {
 204                 p := &(*(*(struct {
 205                         SerializeVer             uint8
 206                         SupportedCompression     CompressionModes
 207                         MinProtoVer, MaxProtoVer uint16
 208                         PlayerName               string
 209
 210                         //mt:opt
 211                         SendFullItemMeta bool
 212                 }))(obj)).MinProtoVer
 213                 *p = read16(r)
 214         }
 215         {
 216                 p := &(*(*(struct {
 217                         SerializeVer             uint8
 218                         SupportedCompression     CompressionModes
 219                         MinProtoVer, MaxProtoVer uint16
 220                         PlayerName               string
 221
 222                         //mt:opt
 223                         SendFullItemMeta bool
 224                 }))(obj)).MaxProtoVer
 225                 *p = read16(r)
 226         }
 227         var local1 []uint8
 228         var local2 uint16
 229         {
 230                 p := &local2
 231                 *p = read16(r)
 232         }
 233         (local1) = make([]uint8, local2)
 234         {
 235                 _, err := io.ReadFull(r, (local1)[:])
 236                 chk(err)
 237         }
 238         ((*(*(struct {
 239                 SerializeVer             uint8
 240                 SupportedCompression     CompressionModes
 241                 MinProtoVer, MaxProtoVer uint16
 242                 PlayerName               string
 243
 244                 //mt:opt
 245                 SendFullItemMeta bool
 246         }))(obj)).PlayerName) = string(local1)
 247         if err := pcall(func() {
 248                 {
 249                         p := &(*(*(struct {
 250                                 SerializeVer             uint8
 251                                 SupportedCompression     CompressionModes
 252                                 MinProtoVer, MaxProtoVer uint16
 253                                 PlayerName               string
 254
 255                                 //mt:opt
 256                                 SendFullItemMeta bool
 257                         }))(obj)).SendFullItemMeta
 258                         switch n := read8(r); n {
 259                         case 0:
 260                                 *p = false
 261                         case 1:
 262                                 *p = true
 263                         default:
 264                                 chk(fmt.Errorf("invalid bool: %d", n))
 265                         }
 266
 267                 }
 268         }); err != nil && err != io.EOF {
 269                 chk(err)
 270         }
 271 }
 272
 273 func (obj *ToSrvInit2) serialize(w io.Writer) {
 274         if len(([]byte((*(*(struct {
 275                 Lang string
 276         }))(obj)).Lang))) > math.MaxUint16 {
 277                 chk(ErrTooLong)
 278         }
 279         {
 280                 x := uint16(len(([]byte((*(*(struct {
 281                         Lang string
 282                 }))(obj)).Lang))))
 283                 write16(w, uint16(x))
 284         }
 285         {
 286                 _, err := w.Write(([]byte((*(*(struct {
 287                         Lang string
 288                 }))(obj)).Lang))[:])
 289                 chk(err)
 290         }
 291 }
 292
 293 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 294         var local3 []uint8
 295         var local4 uint16
 296         {
 297                 p := &local4
 298                 *p = read16(r)
 299         }
 300         (local3) = make([]uint8, local4)
 301         {
 302                 _, err := io.ReadFull(r, (local3)[:])
 303                 chk(err)
 304         }
 305         ((*(*(struct {
 306                 Lang string
 307         }))(obj)).Lang) = string(local3)
 308 }
 309
 310 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 311         if len(([]byte((*(*(struct {
 312                 Channel string
 313         }))(obj)).Channel))) > math.MaxUint16 {
 314                 chk(ErrTooLong)
 315         }
 316         {
 317                 x := uint16(len(([]byte((*(*(struct {
 318                         Channel string
 319                 }))(obj)).Channel))))
 320                 write16(w, uint16(x))
 321         }
 322         {
 323                 _, err := w.Write(([]byte((*(*(struct {
 324                         Channel string
 325                 }))(obj)).Channel))[:])
 326                 chk(err)
 327         }
 328 }
 329
 330 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 331         var local5 []uint8
 332         var local6 uint16
 333         {
 334                 p := &local6
 335                 *p = read16(r)
 336         }
 337         (local5) = make([]uint8, local6)
 338         {
 339                 _, err := io.ReadFull(r, (local5)[:])
 340                 chk(err)
 341         }
 342         ((*(*(struct {
 343                 Channel string
 344         }))(obj)).Channel) = string(local5)
 345 }
 346
 347 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 348         if len(([]byte((*(*(struct {
 349                 Channel string
 350         }))(obj)).Channel))) > math.MaxUint16 {
 351                 chk(ErrTooLong)
 352         }
 353         {
 354                 x := uint16(len(([]byte((*(*(struct {
 355                         Channel string
 356                 }))(obj)).Channel))))
 357                 write16(w, uint16(x))
 358         }
 359         {
 360                 _, err := w.Write(([]byte((*(*(struct {
 361                         Channel string
 362                 }))(obj)).Channel))[:])
 363                 chk(err)
 364         }
 365 }
 366
 367 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 368         var local7 []uint8
 369         var local8 uint16
 370         {
 371                 p := &local8
 372                 *p = read16(r)
 373         }
 374         (local7) = make([]uint8, local8)
 375         {
 376                 _, err := io.ReadFull(r, (local7)[:])
 377                 chk(err)
 378         }
 379         ((*(*(struct {
 380                 Channel string
 381         }))(obj)).Channel) = string(local7)
 382 }
 383
 384 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 385         if len(([]byte((*(*(struct {
 386                 Channel string
 387                 Msg     string
 388         }))(obj)).Channel))) > math.MaxUint16 {
 389                 chk(ErrTooLong)
 390         }
 391         {
 392                 x := uint16(len(([]byte((*(*(struct {
 393                         Channel string
 394                         Msg     string
 395                 }))(obj)).Channel))))
 396                 write16(w, uint16(x))
 397         }
 398         {
 399                 _, err := w.Write(([]byte((*(*(struct {
 400                         Channel string
 401                         Msg     string
 402                 }))(obj)).Channel))[:])
 403                 chk(err)
 404         }
 405         if len(([]byte((*(*(struct {
 406                 Channel string
 407                 Msg     string
 408         }))(obj)).Msg))) > math.MaxUint16 {
 409                 chk(ErrTooLong)
 410         }
 411         {
 412                 x := uint16(len(([]byte((*(*(struct {
 413                         Channel string
 414                         Msg     string
 415                 }))(obj)).Msg))))
 416                 write16(w, uint16(x))
 417         }
 418         {
 419                 _, err := w.Write(([]byte((*(*(struct {
 420                         Channel string
 421                         Msg     string
 422                 }))(obj)).Msg))[:])
 423                 chk(err)
 424         }
 425 }
 426
 427 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 428         var local9 []uint8
 429         var local10 uint16
 430         {
 431                 p := &local10
 432                 *p = read16(r)
 433         }
 434         (local9) = make([]uint8, local10)
 435         {
 436                 _, err := io.ReadFull(r, (local9)[:])
 437                 chk(err)
 438         }
 439         ((*(*(struct {
 440                 Channel string
 441                 Msg     string
 442         }))(obj)).Channel) = string(local9)
 443         var local11 []uint8
 444         var local12 uint16
 445         {
 446                 p := &local12
 447                 *p = read16(r)
 448         }
 449         (local11) = make([]uint8, local12)
 450         {
 451                 _, err := io.ReadFull(r, (local11)[:])
 452                 chk(err)
 453         }
 454         ((*(*(struct {
 455                 Channel string
 456                 Msg     string
 457         }))(obj)).Msg) = string(local11)
 458 }
 459
 460 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 461         if err := pcall(func() {
 462                 ((*(*(struct {
 463                         Pos PlayerPos
 464                 }))(obj)).Pos).serialize(w)
 465         }); err != nil {
 466                 if err == io.EOF {
 467                         chk(io.EOF)
 468                 }
 469                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 470         }
 471 }
 472
 473 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 474         if err := pcall(func() {
 475                 ((*(*(struct {
 476                         Pos PlayerPos
 477                 }))(obj)).Pos).deserialize(r)
 478         }); err != nil {
 479                 if err == io.EOF {
 480                         chk(io.EOF)
 481                 }
 482                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 483         }
 484 }
 485
 486 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 487         if len(((*(*(struct {
 488                 //mt:len8
 489                 Blks [][3]int16
 490         }))(obj)).Blks)) > math.MaxUint8 {
 491                 chk(ErrTooLong)
 492         }
 493         {
 494                 x := uint8(len(((*(*(struct {
 495                         //mt:len8
 496                         Blks [][3]int16
 497                 }))(obj)).Blks)))
 498                 write8(w, uint8(x))
 499         }
 500         for local13 := range (*(*(struct {
 501                 //mt:len8
 502                 Blks [][3]int16
 503         }))(obj)).Blks {
 504                 for local14 := range ((*(*(struct {
 505                         //mt:len8
 506                         Blks [][3]int16
 507                 }))(obj)).Blks)[local13] {
 508                         {
 509                                 x := (((*(*(struct {
 510                                         //mt:len8
 511                                         Blks [][3]int16
 512                                 }))(obj)).Blks)[local13])[local14]
 513                                 write16(w, uint16(x))
 514                         }
 515                 }
 516         }
 517 }
 518
 519 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 520         var local15 uint8
 521         {
 522                 p := &local15
 523                 *p = read8(r)
 524         }
 525         ((*(*(struct {
 526                 //mt:len8
 527                 Blks [][3]int16
 528         }))(obj)).Blks) = make([][3]int16, local15)
 529         for local16 := range (*(*(struct {
 530                 //mt:len8
 531                 Blks [][3]int16
 532         }))(obj)).Blks {
 533                 for local17 := range ((*(*(struct {
 534                         //mt:len8
 535                         Blks [][3]int16
 536                 }))(obj)).Blks)[local16] {
 537                         {
 538                                 p := &(((*(*(struct {
 539                                         //mt:len8
 540                                         Blks [][3]int16
 541                                 }))(obj)).Blks)[local16])[local17]
 542                                 *p = int16(read16(r))
 543                         }
 544                 }
 545         }
 546 }
 547
 548 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 549         if len(((*(*(struct {
 550                 //mt:len8
 551                 Blks [][3]int16
 552         }))(obj)).Blks)) > math.MaxUint8 {
 553                 chk(ErrTooLong)
 554         }
 555         {
 556                 x := uint8(len(((*(*(struct {
 557                         //mt:len8
 558                         Blks [][3]int16
 559                 }))(obj)).Blks)))
 560                 write8(w, uint8(x))
 561         }
 562         for local18 := range (*(*(struct {
 563                 //mt:len8
 564                 Blks [][3]int16
 565         }))(obj)).Blks {
 566                 for local19 := range ((*(*(struct {
 567                         //mt:len8
 568                         Blks [][3]int16
 569                 }))(obj)).Blks)[local18] {
 570                         {
 571                                 x := (((*(*(struct {
 572                                         //mt:len8
 573                                         Blks [][3]int16
 574                                 }))(obj)).Blks)[local18])[local19]
 575                                 write16(w, uint16(x))
 576                         }
 577                 }
 578         }
 579 }
 580
 581 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 582         var local20 uint8
 583         {
 584                 p := &local20
 585                 *p = read8(r)
 586         }
 587         ((*(*(struct {
 588                 //mt:len8
 589                 Blks [][3]int16
 590         }))(obj)).Blks) = make([][3]int16, local20)
 591         for local21 := range (*(*(struct {
 592                 //mt:len8
 593                 Blks [][3]int16
 594         }))(obj)).Blks {
 595                 for local22 := range ((*(*(struct {
 596                         //mt:len8
 597                         Blks [][3]int16
 598                 }))(obj)).Blks)[local21] {
 599                         {
 600                                 p := &(((*(*(struct {
 601                                         //mt:len8
 602                                         Blks [][3]int16
 603                                 }))(obj)).Blks)[local21])[local22]
 604                                 *p = int16(read16(r))
 605                         }
 606                 }
 607         }
 608 }
 609
 610 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 611         {
 612                 _, err := w.Write(([]byte((*(*(struct {
 613                         //mt:raw
 614                         Action string
 615                 }))(obj)).Action))[:])
 616                 chk(err)
 617         }
 618 }
 619
 620 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 621         var local23 []uint8
 622         {
 623                 var err error
 624                 (local23), err = io.ReadAll(r)
 625                 chk(err)
 626         }
 627         ((*(*(struct {
 628                 //mt:raw
 629                 Action string
 630         }))(obj)).Action) = string(local23)
 631 }
 632
 633 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 634         local24 := utf16.Encode([]rune((*(*(struct {
 635                 //mt:utf16
 636                 Msg string
 637         }))(obj)).Msg))
 638         if len((local24)) > math.MaxUint16 {
 639                 chk(ErrTooLong)
 640         }
 641         {
 642                 x := uint16(len((local24)))
 643                 write16(w, uint16(x))
 644         }
 645         for local25 := range local24 {
 646                 {
 647                         x := (local24)[local25]
 648                         write16(w, uint16(x))
 649                 }
 650         }
 651 }
 652
 653 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 654         var local26 []uint16
 655         var local27 uint16
 656         {
 657                 p := &local27
 658                 *p = read16(r)
 659         }
 660         (local26) = make([]uint16, local27)
 661         for local28 := range local26 {
 662                 {
 663                         p := &(local26)[local28]
 664                         *p = read16(r)
 665                 }
 666         }
 667         (*(*(struct {
 668                 //mt:utf16
 669                 Msg string
 670         }))(obj)).Msg = string(utf16.Decode(local26))
 671 }
 672
 673 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 674         {
 675                 x := (*(*(struct {
 676                         Amount uint16
 677                 }))(obj)).Amount
 678                 write16(w, uint16(x))
 679         }
 680 }
 681
 682 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 683         {
 684                 p := &(*(*(struct {
 685                         Amount uint16
 686                 }))(obj)).Amount
 687                 *p = read16(r)
 688         }
 689 }
 690
 691 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 692         {
 693                 x := (*(*(struct {
 694                         Slot uint16
 695                 }))(obj)).Slot
 696                 write16(w, uint16(x))
 697         }
 698 }
 699
 700 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 701         {
 702                 p := &(*(*(struct {
 703                         Slot uint16
 704                 }))(obj)).Slot
 705                 *p = read16(r)
 706         }
 707 }
 708
 709 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 710 }
 711
 712 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 713 }
 714
 715 func (obj *ToSrvInteract) serialize(w io.Writer) {
 716         if err := pcall(func() {
 717                 ((*(*(struct {
 718                         Action   Interaction
 719                         ItemSlot uint16
 720                         //mt:lenhdr 32
 721                         Pointed PointedThing
 722                         //mt:end
 723                         Pos PlayerPos
 724                 }))(obj)).Action).serialize(w)
 725         }); err != nil {
 726                 if err == io.EOF {
 727                         chk(io.EOF)
 728                 }
 729                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Interaction", err))
 730         }
 731         {
 732                 x := (*(*(struct {
 733                         Action   Interaction
 734                         ItemSlot uint16
 735                         //mt:lenhdr 32
 736                         Pointed PointedThing
 737                         //mt:end
 738                         Pos PlayerPos
 739                 }))(obj)).ItemSlot
 740                 write16(w, uint16(x))
 741         }
 742         {
 743                 ow := w
 744                 w := new(bytes.Buffer)
 745                 {
 746                         x := (*(*(struct {
 747                                 Action   Interaction
 748                                 ItemSlot uint16
 749                                 //mt:lenhdr 32
 750                                 Pointed PointedThing
 751                                 //mt:end
 752                                 Pos PlayerPos
 753                         }))(obj)).Pointed
 754                         chk(writePointedThing(w, x))
 755
 756                 }
 757                 {
 758                         buf := w
 759                         w := ow
 760                         if len((buf.Bytes())) > math.MaxUint32 {
 761                                 chk(ErrTooLong)
 762                         }
 763                         {
 764                                 x := uint32(len((buf.Bytes())))
 765                                 write32(w, uint32(x))
 766                         }
 767                         {
 768                                 _, err := w.Write((buf.Bytes())[:])
 769                                 chk(err)
 770                         }
 771                 }
 772         }
 773         if err := pcall(func() {
 774                 ((*(*(struct {
 775                         Action   Interaction
 776                         ItemSlot uint16
 777                         //mt:lenhdr 32
 778                         Pointed PointedThing
 779                         //mt:end
 780                         Pos PlayerPos
 781                 }))(obj)).Pos).serialize(w)
 782         }); err != nil {
 783                 if err == io.EOF {
 784                         chk(io.EOF)
 785                 }
 786                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 787         }
 788 }
 789
 790 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 791         if err := pcall(func() {
 792                 ((*(*(struct {
 793                         Action   Interaction
 794                         ItemSlot uint16
 795                         //mt:lenhdr 32
 796                         Pointed PointedThing
 797                         //mt:end
 798                         Pos PlayerPos
 799                 }))(obj)).Action).deserialize(r)
 800         }); err != nil {
 801                 if err == io.EOF {
 802                         chk(io.EOF)
 803                 }
 804                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Interaction", err))
 805         }
 806         {
 807                 p := &(*(*(struct {
 808                         Action   Interaction
 809                         ItemSlot uint16
 810                         //mt:lenhdr 32
 811                         Pointed PointedThing
 812                         //mt:end
 813                         Pos PlayerPos
 814                 }))(obj)).ItemSlot
 815                 *p = read16(r)
 816         }
 817         {
 818                 var n uint32
 819                 {
 820                         p := &n
 821                         *p = read32(r)
 822                 }
 823                 r := &io.LimitedReader{R: r, N: int64(n)}
 824                 {
 825                         p := &(*(*(struct {
 826                                 Action   Interaction
 827                                 ItemSlot uint16
 828                                 //mt:lenhdr 32
 829                                 Pointed PointedThing
 830                                 //mt:end
 831                                 Pos PlayerPos
 832                         }))(obj)).Pointed
 833                         {
 834                                 var err error
 835                                 *p, err = readPointedThing(r)
 836                                 chk(err)
 837                         }
 838
 839                 }
 840                 if r.N > 0 {
 841                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 842                 }
 843         }
 844         if err := pcall(func() {
 845                 ((*(*(struct {
 846                         Action   Interaction
 847                         ItemSlot uint16
 848                         //mt:lenhdr 32
 849                         Pointed PointedThing
 850                         //mt:end
 851                         Pos PlayerPos
 852                 }))(obj)).Pos).deserialize(r)
 853         }); err != nil {
 854                 if err == io.EOF {
 855                         chk(io.EOF)
 856                 }
 857                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerPos", err))
 858         }
 859 }
 860
 861 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 862         if len(((*(*(struct {
 863                 IDs []SoundID
 864         }))(obj)).IDs)) > math.MaxUint16 {
 865                 chk(ErrTooLong)
 866         }
 867         {
 868                 x := uint16(len(((*(*(struct {
 869                         IDs []SoundID
 870                 }))(obj)).IDs)))
 871                 write16(w, uint16(x))
 872         }
 873         for local29 := range (*(*(struct {
 874                 IDs []SoundID
 875         }))(obj)).IDs {
 876                 if err := pcall(func() {
 877                         (((*(*(struct {
 878                                 IDs []SoundID
 879                         }))(obj)).IDs)[local29]).serialize(w)
 880                 }); err != nil {
 881                         if err == io.EOF {
 882                                 chk(io.EOF)
 883                         }
 884                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
 885                 }
 886         }
 887 }
 888
 889 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 890         var local30 uint16
 891         {
 892                 p := &local30
 893                 *p = read16(r)
 894         }
 895         ((*(*(struct {
 896                 IDs []SoundID
 897         }))(obj)).IDs) = make([]SoundID, local30)
 898         for local31 := range (*(*(struct {
 899                 IDs []SoundID
 900         }))(obj)).IDs {
 901                 if err := pcall(func() {
 902                         (((*(*(struct {
 903                                 IDs []SoundID
 904                         }))(obj)).IDs)[local31]).deserialize(r)
 905                 }); err != nil {
 906                         if err == io.EOF {
 907                                 chk(io.EOF)
 908                         }
 909                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
 910                 }
 911         }
 912 }
 913
 914 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 915         for local32 := range (*(*(struct {
 916                 Pos      [3]int16
 917                 Formname string
 918                 Fields   []Field
 919         }))(obj)).Pos {
 920                 {
 921                         x := ((*(*(struct {
 922                                 Pos      [3]int16
 923                                 Formname string
 924                                 Fields   []Field
 925                         }))(obj)).Pos)[local32]
 926                         write16(w, uint16(x))
 927                 }
 928         }
 929         if len(([]byte((*(*(struct {
 930                 Pos      [3]int16
 931                 Formname string
 932                 Fields   []Field
 933         }))(obj)).Formname))) > math.MaxUint16 {
 934                 chk(ErrTooLong)
 935         }
 936         {
 937                 x := uint16(len(([]byte((*(*(struct {
 938                         Pos      [3]int16
 939                         Formname string
 940                         Fields   []Field
 941                 }))(obj)).Formname))))
 942                 write16(w, uint16(x))
 943         }
 944         {
 945                 _, err := w.Write(([]byte((*(*(struct {
 946                         Pos      [3]int16
 947                         Formname string
 948                         Fields   []Field
 949                 }))(obj)).Formname))[:])
 950                 chk(err)
 951         }
 952         if len(((*(*(struct {
 953                 Pos      [3]int16
 954                 Formname string
 955                 Fields   []Field
 956         }))(obj)).Fields)) > math.MaxUint16 {
 957                 chk(ErrTooLong)
 958         }
 959         {
 960                 x := uint16(len(((*(*(struct {
 961                         Pos      [3]int16
 962                         Formname string
 963                         Fields   []Field
 964                 }))(obj)).Fields)))
 965                 write16(w, uint16(x))
 966         }
 967         for local33 := range (*(*(struct {
 968                 Pos      [3]int16
 969                 Formname string
 970                 Fields   []Field
 971         }))(obj)).Fields {
 972                 if err := pcall(func() {
 973                         (((*(*(struct {
 974                                 Pos      [3]int16
 975                                 Formname string
 976                                 Fields   []Field
 977                         }))(obj)).Fields)[local33]).serialize(w)
 978                 }); err != nil {
 979                         if err == io.EOF {
 980                                 chk(io.EOF)
 981                         }
 982                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
 983                 }
 984         }
 985 }
 986
 987 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 988         for local34 := range (*(*(struct {
 989                 Pos      [3]int16
 990                 Formname string
 991                 Fields   []Field
 992         }))(obj)).Pos {
 993                 {
 994                         p := &((*(*(struct {
 995                                 Pos      [3]int16
 996                                 Formname string
 997                                 Fields   []Field
 998                         }))(obj)).Pos)[local34]
 999                         *p = int16(read16(r))
1000                 }
1001         }
1002         var local35 []uint8
1003         var local36 uint16
1004         {
1005                 p := &local36
1006                 *p = read16(r)
1007         }
1008         (local35) = make([]uint8, local36)
1009         {
1010                 _, err := io.ReadFull(r, (local35)[:])
1011                 chk(err)
1012         }
1013         ((*(*(struct {
1014                 Pos      [3]int16
1015                 Formname string
1016                 Fields   []Field
1017         }))(obj)).Formname) = string(local35)
1018         var local37 uint16
1019         {
1020                 p := &local37
1021                 *p = read16(r)
1022         }
1023         ((*(*(struct {
1024                 Pos      [3]int16
1025                 Formname string
1026                 Fields   []Field
1027         }))(obj)).Fields) = make([]Field, local37)
1028         for local38 := range (*(*(struct {
1029                 Pos      [3]int16
1030                 Formname string
1031                 Fields   []Field
1032         }))(obj)).Fields {
1033                 if err := pcall(func() {
1034                         (((*(*(struct {
1035                                 Pos      [3]int16
1036                                 Formname string
1037                                 Fields   []Field
1038                         }))(obj)).Fields)[local38]).deserialize(r)
1039                 }); err != nil {
1040                         if err == io.EOF {
1041                                 chk(io.EOF)
1042                         }
1043                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
1044                 }
1045         }
1046 }
1047
1048 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1049         if len(([]byte((*(*(struct {
1050                 Formname string
1051                 Fields   []Field
1052         }))(obj)).Formname))) > math.MaxUint16 {
1053                 chk(ErrTooLong)
1054         }
1055         {
1056                 x := uint16(len(([]byte((*(*(struct {
1057                         Formname string
1058                         Fields   []Field
1059                 }))(obj)).Formname))))
1060                 write16(w, uint16(x))
1061         }
1062         {
1063                 _, err := w.Write(([]byte((*(*(struct {
1064                         Formname string
1065                         Fields   []Field
1066                 }))(obj)).Formname))[:])
1067                 chk(err)
1068         }
1069         if len(((*(*(struct {
1070                 Formname string
1071                 Fields   []Field
1072         }))(obj)).Fields)) > math.MaxUint16 {
1073                 chk(ErrTooLong)
1074         }
1075         {
1076                 x := uint16(len(((*(*(struct {
1077                         Formname string
1078                         Fields   []Field
1079                 }))(obj)).Fields)))
1080                 write16(w, uint16(x))
1081         }
1082         for local39 := range (*(*(struct {
1083                 Formname string
1084                 Fields   []Field
1085         }))(obj)).Fields {
1086                 if err := pcall(func() {
1087                         (((*(*(struct {
1088                                 Formname string
1089                                 Fields   []Field
1090                         }))(obj)).Fields)[local39]).serialize(w)
1091                 }); err != nil {
1092                         if err == io.EOF {
1093                                 chk(io.EOF)
1094                         }
1095                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
1096                 }
1097         }
1098 }
1099
1100 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1101         var local40 []uint8
1102         var local41 uint16
1103         {
1104                 p := &local41
1105                 *p = read16(r)
1106         }
1107         (local40) = make([]uint8, local41)
1108         {
1109                 _, err := io.ReadFull(r, (local40)[:])
1110                 chk(err)
1111         }
1112         ((*(*(struct {
1113                 Formname string
1114                 Fields   []Field
1115         }))(obj)).Formname) = string(local40)
1116         var local42 uint16
1117         {
1118                 p := &local42
1119                 *p = read16(r)
1120         }
1121         ((*(*(struct {
1122                 Formname string
1123                 Fields   []Field
1124         }))(obj)).Fields) = make([]Field, local42)
1125         for local43 := range (*(*(struct {
1126                 Formname string
1127                 Fields   []Field
1128         }))(obj)).Fields {
1129                 if err := pcall(func() {
1130                         (((*(*(struct {
1131                                 Formname string
1132                                 Fields   []Field
1133                         }))(obj)).Fields)[local43]).deserialize(r)
1134                 }); err != nil {
1135                         if err == io.EOF {
1136                                 chk(io.EOF)
1137                         }
1138                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
1139                 }
1140         }
1141 }
1142
1143 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1144         if len(((*(*(struct {
1145                 Filenames []string
1146         }))(obj)).Filenames)) > math.MaxUint16 {
1147                 chk(ErrTooLong)
1148         }
1149         {
1150                 x := uint16(len(((*(*(struct {
1151                         Filenames []string
1152                 }))(obj)).Filenames)))
1153                 write16(w, uint16(x))
1154         }
1155         for local44 := range (*(*(struct {
1156                 Filenames []string
1157         }))(obj)).Filenames {
1158                 if len(([]byte(((*(*(struct {
1159                         Filenames []string
1160                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1161                         chk(ErrTooLong)
1162                 }
1163                 {
1164                         x := uint16(len(([]byte(((*(*(struct {
1165                                 Filenames []string
1166                         }))(obj)).Filenames)[local44]))))
1167                         write16(w, uint16(x))
1168                 }
1169                 {
1170                         _, err := w.Write(([]byte(((*(*(struct {
1171                                 Filenames []string
1172                         }))(obj)).Filenames)[local44]))[:])
1173                         chk(err)
1174                 }
1175         }
1176 }
1177
1178 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1179         var local45 uint16
1180         {
1181                 p := &local45
1182                 *p = read16(r)
1183         }
1184         ((*(*(struct {
1185                 Filenames []string
1186         }))(obj)).Filenames) = make([]string, local45)
1187         for local46 := range (*(*(struct {
1188                 Filenames []string
1189         }))(obj)).Filenames {
1190                 var local47 []uint8
1191                 var local48 uint16
1192                 {
1193                         p := &local48
1194                         *p = read16(r)
1195                 }
1196                 (local47) = make([]uint8, local48)
1197                 {
1198                         _, err := io.ReadFull(r, (local47)[:])
1199                         chk(err)
1200                 }
1201                 (((*(*(struct {
1202                         Filenames []string
1203                 }))(obj)).Filenames)[local46]) = string(local47)
1204         }
1205 }
1206
1207 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1208         {
1209                 x := (*(*(struct {
1210                         // Version information.
1211                         Major, Minor, Patch uint8
1212                         Reserved            uint8
1213                         Version             string
1214                         Formspec            uint16
1215                 }))(obj)).Major
1216                 write8(w, uint8(x))
1217         }
1218         {
1219                 x := (*(*(struct {
1220                         // Version information.
1221                         Major, Minor, Patch uint8
1222                         Reserved            uint8
1223                         Version             string
1224                         Formspec            uint16
1225                 }))(obj)).Minor
1226                 write8(w, uint8(x))
1227         }
1228         {
1229                 x := (*(*(struct {
1230                         // Version information.
1231                         Major, Minor, Patch uint8
1232                         Reserved            uint8
1233                         Version             string
1234                         Formspec            uint16
1235                 }))(obj)).Patch
1236                 write8(w, uint8(x))
1237         }
1238         {
1239                 x := (*(*(struct {
1240                         // Version information.
1241                         Major, Minor, Patch uint8
1242                         Reserved            uint8
1243                         Version             string
1244                         Formspec            uint16
1245                 }))(obj)).Reserved
1246                 write8(w, uint8(x))
1247         }
1248         if len(([]byte((*(*(struct {
1249                 // Version information.
1250                 Major, Minor, Patch uint8
1251                 Reserved            uint8
1252                 Version             string
1253                 Formspec            uint16
1254         }))(obj)).Version))) > math.MaxUint16 {
1255                 chk(ErrTooLong)
1256         }
1257         {
1258                 x := uint16(len(([]byte((*(*(struct {
1259                         // Version information.
1260                         Major, Minor, Patch uint8
1261                         Reserved            uint8
1262                         Version             string
1263                         Formspec            uint16
1264                 }))(obj)).Version))))
1265                 write16(w, uint16(x))
1266         }
1267         {
1268                 _, err := w.Write(([]byte((*(*(struct {
1269                         // Version information.
1270                         Major, Minor, Patch uint8
1271                         Reserved            uint8
1272                         Version             string
1273                         Formspec            uint16
1274                 }))(obj)).Version))[:])
1275                 chk(err)
1276         }
1277         {
1278                 x := (*(*(struct {
1279                         // Version information.
1280                         Major, Minor, Patch uint8
1281                         Reserved            uint8
1282                         Version             string
1283                         Formspec            uint16
1284                 }))(obj)).Formspec
1285                 write16(w, uint16(x))
1286         }
1287 }
1288
1289 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1290         {
1291                 p := &(*(*(struct {
1292                         // Version information.
1293                         Major, Minor, Patch uint8
1294                         Reserved            uint8
1295                         Version             string
1296                         Formspec            uint16
1297                 }))(obj)).Major
1298                 *p = read8(r)
1299         }
1300         {
1301                 p := &(*(*(struct {
1302                         // Version information.
1303                         Major, Minor, Patch uint8
1304                         Reserved            uint8
1305                         Version             string
1306                         Formspec            uint16
1307                 }))(obj)).Minor
1308                 *p = read8(r)
1309         }
1310         {
1311                 p := &(*(*(struct {
1312                         // Version information.
1313                         Major, Minor, Patch uint8
1314                         Reserved            uint8
1315                         Version             string
1316                         Formspec            uint16
1317                 }))(obj)).Patch
1318                 *p = read8(r)
1319         }
1320         {
1321                 p := &(*(*(struct {
1322                         // Version information.
1323                         Major, Minor, Patch uint8
1324                         Reserved            uint8
1325                         Version             string
1326                         Formspec            uint16
1327                 }))(obj)).Reserved
1328                 *p = read8(r)
1329         }
1330         var local49 []uint8
1331         var local50 uint16
1332         {
1333                 p := &local50
1334                 *p = read16(r)
1335         }
1336         (local49) = make([]uint8, local50)
1337         {
1338                 _, err := io.ReadFull(r, (local49)[:])
1339                 chk(err)
1340         }
1341         ((*(*(struct {
1342                 // Version information.
1343                 Major, Minor, Patch uint8
1344                 Reserved            uint8
1345                 Version             string
1346                 Formspec            uint16
1347         }))(obj)).Version) = string(local49)
1348         {
1349                 p := &(*(*(struct {
1350                         // Version information.
1351                         Major, Minor, Patch uint8
1352                         Reserved            uint8
1353                         Version             string
1354                         Formspec            uint16
1355                 }))(obj)).Formspec
1356                 *p = read16(r)
1357         }
1358 }
1359
1360 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1361         if len(((*(*(struct {
1362                 Salt        []byte
1363                 Verifier    []byte
1364                 EmptyPasswd bool
1365         }))(obj)).Salt)) > math.MaxUint16 {
1366                 chk(ErrTooLong)
1367         }
1368         {
1369                 x := uint16(len(((*(*(struct {
1370                         Salt        []byte
1371                         Verifier    []byte
1372                         EmptyPasswd bool
1373                 }))(obj)).Salt)))
1374                 write16(w, uint16(x))
1375         }
1376         {
1377                 _, err := w.Write(((*(*(struct {
1378                         Salt        []byte
1379                         Verifier    []byte
1380                         EmptyPasswd bool
1381                 }))(obj)).Salt)[:])
1382                 chk(err)
1383         }
1384         if len(((*(*(struct {
1385                 Salt        []byte
1386                 Verifier    []byte
1387                 EmptyPasswd bool
1388         }))(obj)).Verifier)) > math.MaxUint16 {
1389                 chk(ErrTooLong)
1390         }
1391         {
1392                 x := uint16(len(((*(*(struct {
1393                         Salt        []byte
1394                         Verifier    []byte
1395                         EmptyPasswd bool
1396                 }))(obj)).Verifier)))
1397                 write16(w, uint16(x))
1398         }
1399         {
1400                 _, err := w.Write(((*(*(struct {
1401                         Salt        []byte
1402                         Verifier    []byte
1403                         EmptyPasswd bool
1404                 }))(obj)).Verifier)[:])
1405                 chk(err)
1406         }
1407         {
1408                 x := (*(*(struct {
1409                         Salt        []byte
1410                         Verifier    []byte
1411                         EmptyPasswd bool
1412                 }))(obj)).EmptyPasswd
1413                 if x {
1414                         write8(w, 1)
1415                 } else {
1416                         write8(w, 0)
1417                 }
1418
1419         }
1420 }
1421
1422 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1423         var local51 uint16
1424         {
1425                 p := &local51
1426                 *p = read16(r)
1427         }
1428         ((*(*(struct {
1429                 Salt        []byte
1430                 Verifier    []byte
1431                 EmptyPasswd bool
1432         }))(obj)).Salt) = make([]byte, local51)
1433         {
1434                 _, err := io.ReadFull(r, ((*(*(struct {
1435                         Salt        []byte
1436                         Verifier    []byte
1437                         EmptyPasswd bool
1438                 }))(obj)).Salt)[:])
1439                 chk(err)
1440         }
1441         var local52 uint16
1442         {
1443                 p := &local52
1444                 *p = read16(r)
1445         }
1446         ((*(*(struct {
1447                 Salt        []byte
1448                 Verifier    []byte
1449                 EmptyPasswd bool
1450         }))(obj)).Verifier) = make([]byte, local52)
1451         {
1452                 _, err := io.ReadFull(r, ((*(*(struct {
1453                         Salt        []byte
1454                         Verifier    []byte
1455                         EmptyPasswd bool
1456                 }))(obj)).Verifier)[:])
1457                 chk(err)
1458         }
1459         {
1460                 p := &(*(*(struct {
1461                         Salt        []byte
1462                         Verifier    []byte
1463                         EmptyPasswd bool
1464                 }))(obj)).EmptyPasswd
1465                 switch n := read8(r); n {
1466                 case 0:
1467                         *p = false
1468                 case 1:
1469                         *p = true
1470                 default:
1471                         chk(fmt.Errorf("invalid bool: %d", n))
1472                 }
1473
1474         }
1475 }
1476
1477 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1478         if len(((*(*(struct {
1479                 A      []byte
1480                 NoSHA1 bool
1481         }))(obj)).A)) > math.MaxUint16 {
1482                 chk(ErrTooLong)
1483         }
1484         {
1485                 x := uint16(len(((*(*(struct {
1486                         A      []byte
1487                         NoSHA1 bool
1488                 }))(obj)).A)))
1489                 write16(w, uint16(x))
1490         }
1491         {
1492                 _, err := w.Write(((*(*(struct {
1493                         A      []byte
1494                         NoSHA1 bool
1495                 }))(obj)).A)[:])
1496                 chk(err)
1497         }
1498         {
1499                 x := (*(*(struct {
1500                         A      []byte
1501                         NoSHA1 bool
1502                 }))(obj)).NoSHA1
1503                 if x {
1504                         write8(w, 1)
1505                 } else {
1506                         write8(w, 0)
1507                 }
1508
1509         }
1510 }
1511
1512 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1513         var local53 uint16
1514         {
1515                 p := &local53
1516                 *p = read16(r)
1517         }
1518         ((*(*(struct {
1519                 A      []byte
1520                 NoSHA1 bool
1521         }))(obj)).A) = make([]byte, local53)
1522         {
1523                 _, err := io.ReadFull(r, ((*(*(struct {
1524                         A      []byte
1525                         NoSHA1 bool
1526                 }))(obj)).A)[:])
1527                 chk(err)
1528         }
1529         {
1530                 p := &(*(*(struct {
1531                         A      []byte
1532                         NoSHA1 bool
1533                 }))(obj)).NoSHA1
1534                 switch n := read8(r); n {
1535                 case 0:
1536                         *p = false
1537                 case 1:
1538                         *p = true
1539                 default:
1540                         chk(fmt.Errorf("invalid bool: %d", n))
1541                 }
1542
1543         }
1544 }
1545
1546 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1547         if len(((*(*(struct {
1548                 M []byte
1549         }))(obj)).M)) > math.MaxUint16 {
1550                 chk(ErrTooLong)
1551         }
1552         {
1553                 x := uint16(len(((*(*(struct {
1554                         M []byte
1555                 }))(obj)).M)))
1556                 write16(w, uint16(x))
1557         }
1558         {
1559                 _, err := w.Write(((*(*(struct {
1560                         M []byte
1561                 }))(obj)).M)[:])
1562                 chk(err)
1563         }
1564 }
1565
1566 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1567         var local54 uint16
1568         {
1569                 p := &local54
1570                 *p = read16(r)
1571         }
1572         ((*(*(struct {
1573                 M []byte
1574         }))(obj)).M) = make([]byte, local54)
1575         {
1576                 _, err := io.ReadFull(r, ((*(*(struct {
1577                         M []byte
1578                 }))(obj)).M)[:])
1579                 chk(err)
1580         }
1581 }
1582
1583 func (obj *ToCltHello) serialize(w io.Writer) {
1584         {
1585                 x := (*(*(struct {
1586                         SerializeVer uint8
1587                         Compression  CompressionModes
1588                         ProtoVer     uint16
1589                         AuthMethods
1590                         Username string
1591                 }))(obj)).SerializeVer
1592                 write8(w, uint8(x))
1593         }
1594         if err := pcall(func() {
1595                 ((*(*(struct {
1596                         SerializeVer uint8
1597                         Compression  CompressionModes
1598                         ProtoVer     uint16
1599                         AuthMethods
1600                         Username string
1601                 }))(obj)).Compression).serialize(w)
1602         }); err != nil {
1603                 if err == io.EOF {
1604                         chk(io.EOF)
1605                 }
1606                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
1607         }
1608         {
1609                 x := (*(*(struct {
1610                         SerializeVer uint8
1611                         Compression  CompressionModes
1612                         ProtoVer     uint16
1613                         AuthMethods
1614                         Username string
1615                 }))(obj)).ProtoVer
1616                 write16(w, uint16(x))
1617         }
1618         if err := pcall(func() {
1619                 ((*(*(struct {
1620                         SerializeVer uint8
1621                         Compression  CompressionModes
1622                         ProtoVer     uint16
1623                         AuthMethods
1624                         Username string
1625                 }))(obj)).AuthMethods).serialize(w)
1626         }); err != nil {
1627                 if err == io.EOF {
1628                         chk(io.EOF)
1629                 }
1630                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1631         }
1632         if len(([]byte((*(*(struct {
1633                 SerializeVer uint8
1634                 Compression  CompressionModes
1635                 ProtoVer     uint16
1636                 AuthMethods
1637                 Username string
1638         }))(obj)).Username))) > math.MaxUint16 {
1639                 chk(ErrTooLong)
1640         }
1641         {
1642                 x := uint16(len(([]byte((*(*(struct {
1643                         SerializeVer uint8
1644                         Compression  CompressionModes
1645                         ProtoVer     uint16
1646                         AuthMethods
1647                         Username string
1648                 }))(obj)).Username))))
1649                 write16(w, uint16(x))
1650         }
1651         {
1652                 _, err := w.Write(([]byte((*(*(struct {
1653                         SerializeVer uint8
1654                         Compression  CompressionModes
1655                         ProtoVer     uint16
1656                         AuthMethods
1657                         Username string
1658                 }))(obj)).Username))[:])
1659                 chk(err)
1660         }
1661 }
1662
1663 func (obj *ToCltHello) deserialize(r io.Reader) {
1664         {
1665                 p := &(*(*(struct {
1666                         SerializeVer uint8
1667                         Compression  CompressionModes
1668                         ProtoVer     uint16
1669                         AuthMethods
1670                         Username string
1671                 }))(obj)).SerializeVer
1672                 *p = read8(r)
1673         }
1674         if err := pcall(func() {
1675                 ((*(*(struct {
1676                         SerializeVer uint8
1677                         Compression  CompressionModes
1678                         ProtoVer     uint16
1679                         AuthMethods
1680                         Username string
1681                 }))(obj)).Compression).deserialize(r)
1682         }); err != nil {
1683                 if err == io.EOF {
1684                         chk(io.EOF)
1685                 }
1686                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CompressionModes", err))
1687         }
1688         {
1689                 p := &(*(*(struct {
1690                         SerializeVer uint8
1691                         Compression  CompressionModes
1692                         ProtoVer     uint16
1693                         AuthMethods
1694                         Username string
1695                 }))(obj)).ProtoVer
1696                 *p = read16(r)
1697         }
1698         if err := pcall(func() {
1699                 ((*(*(struct {
1700                         SerializeVer uint8
1701                         Compression  CompressionModes
1702                         ProtoVer     uint16
1703                         AuthMethods
1704                         Username string
1705                 }))(obj)).AuthMethods).deserialize(r)
1706         }); err != nil {
1707                 if err == io.EOF {
1708                         chk(io.EOF)
1709                 }
1710                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1711         }
1712         var local55 []uint8
1713         var local56 uint16
1714         {
1715                 p := &local56
1716                 *p = read16(r)
1717         }
1718         (local55) = make([]uint8, local56)
1719         {
1720                 _, err := io.ReadFull(r, (local55)[:])
1721                 chk(err)
1722         }
1723         ((*(*(struct {
1724                 SerializeVer uint8
1725                 Compression  CompressionModes
1726                 ProtoVer     uint16
1727                 AuthMethods
1728                 Username string
1729         }))(obj)).Username) = string(local55)
1730 }
1731
1732 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1733         if err := pcall(func() {
1734                 ((*(*(struct {
1735                         // The client does the equivalent of
1736                         //      PlayerPos[1] -= 5
1737                         // before using PlayerPos.
1738                         PlayerPos Pos
1739
1740                         MapSeed         uint64
1741                         SendInterval    float32
1742                         SudoAuthMethods AuthMethods
1743                 }))(obj)).PlayerPos).serialize(w)
1744         }); err != nil {
1745                 if err == io.EOF {
1746                         chk(io.EOF)
1747                 }
1748                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
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)).MapSeed
1761                 write64(w, uint64(x))
1762
1763         }
1764         {
1765                 x := (*(*(struct {
1766                         // The client does the equivalent of
1767                         //      PlayerPos[1] -= 5
1768                         // before using PlayerPos.
1769                         PlayerPos Pos
1770
1771                         MapSeed         uint64
1772                         SendInterval    float32
1773                         SudoAuthMethods AuthMethods
1774                 }))(obj)).SendInterval
1775                 write32(w, math.Float32bits(x))
1776         }
1777         if err := pcall(func() {
1778                 ((*(*(struct {
1779                         // The client does the equivalent of
1780                         //      PlayerPos[1] -= 5
1781                         // before using PlayerPos.
1782                         PlayerPos Pos
1783
1784                         MapSeed         uint64
1785                         SendInterval    float32
1786                         SudoAuthMethods AuthMethods
1787                 }))(obj)).SudoAuthMethods).serialize(w)
1788         }); err != nil {
1789                 if err == io.EOF {
1790                         chk(io.EOF)
1791                 }
1792                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1793         }
1794 }
1795
1796 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1797         if err := pcall(func() {
1798                 ((*(*(struct {
1799                         // The client does the equivalent of
1800                         //      PlayerPos[1] -= 5
1801                         // before using PlayerPos.
1802                         PlayerPos Pos
1803
1804                         MapSeed         uint64
1805                         SendInterval    float32
1806                         SudoAuthMethods AuthMethods
1807                 }))(obj)).PlayerPos).deserialize(r)
1808         }); err != nil {
1809                 if err == io.EOF {
1810                         chk(io.EOF)
1811                 }
1812                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
1813         }
1814         {
1815                 p := &(*(*(struct {
1816                         // The client does the equivalent of
1817                         //      PlayerPos[1] -= 5
1818                         // before using PlayerPos.
1819                         PlayerPos Pos
1820
1821                         MapSeed         uint64
1822                         SendInterval    float32
1823                         SudoAuthMethods AuthMethods
1824                 }))(obj)).MapSeed
1825                 *p = read64(r)
1826
1827         }
1828         {
1829                 p := &(*(*(struct {
1830                         // The client does the equivalent of
1831                         //      PlayerPos[1] -= 5
1832                         // before using PlayerPos.
1833                         PlayerPos Pos
1834
1835                         MapSeed         uint64
1836                         SendInterval    float32
1837                         SudoAuthMethods AuthMethods
1838                 }))(obj)).SendInterval
1839                 *p = math.Float32frombits(read32(r))
1840         }
1841         if err := pcall(func() {
1842                 ((*(*(struct {
1843                         // The client does the equivalent of
1844                         //      PlayerPos[1] -= 5
1845                         // before using PlayerPos.
1846                         PlayerPos Pos
1847
1848                         MapSeed         uint64
1849                         SendInterval    float32
1850                         SudoAuthMethods AuthMethods
1851                 }))(obj)).SudoAuthMethods).deserialize(r)
1852         }); err != nil {
1853                 if err == io.EOF {
1854                         chk(io.EOF)
1855                 }
1856                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1857         }
1858 }
1859
1860 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1861         if err := pcall(func() {
1862                 ((*(*(struct {
1863                         SudoAuthMethods AuthMethods
1864                 }))(obj)).SudoAuthMethods).serialize(w)
1865         }); err != nil {
1866                 if err == io.EOF {
1867                         chk(io.EOF)
1868                 }
1869                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1870         }
1871         {
1872                 local57 := [15]byte{}
1873                 {
1874                         _, err := w.Write((local57)[:])
1875                         chk(err)
1876                 }
1877         }
1878 }
1879
1880 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1881         if err := pcall(func() {
1882                 ((*(*(struct {
1883                         SudoAuthMethods AuthMethods
1884                 }))(obj)).SudoAuthMethods).deserialize(r)
1885         }); err != nil {
1886                 if err == io.EOF {
1887                         chk(io.EOF)
1888                 }
1889                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AuthMethods", err))
1890         }
1891         {
1892                 var local58 [15]byte
1893                 local59 := [15]byte{}
1894                 {
1895                         _, err := io.ReadFull(r, (local58)[:])
1896                         chk(err)
1897                 }
1898                 if local58 != local59 {
1899                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1900                 }
1901         }
1902 }
1903
1904 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1905 }
1906
1907 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1908 }
1909
1910 func (obj *ToCltKick) serialize(w io.Writer) {
1911         if err := pcall(func() {
1912                 ((*(*(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).serialize(w)
1921         }); err != nil {
1922                 if err == io.EOF {
1923                         chk(io.EOF)
1924                 }
1925                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.KickReason", err))
1926         }
1927         if !((*(*(struct {
1928                 Reason KickReason
1929
1930                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1931                 Custom string
1932
1933                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1934                 Reconnect bool
1935         }))(obj)).Reason < maxKickReason) {
1936                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1937         }
1938         if dr := (*(*(struct {
1939                 Reason KickReason
1940
1941                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1942                 Custom string
1943
1944                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1945                 Reconnect bool
1946         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1947                 if len(([]byte((*(*(struct {
1948                         Reason KickReason
1949
1950                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1951                         Custom string
1952
1953                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1954                         Reconnect bool
1955                 }))(obj)).Custom))) > math.MaxUint16 {
1956                         chk(ErrTooLong)
1957                 }
1958                 {
1959                         x := uint16(len(([]byte((*(*(struct {
1960                                 Reason KickReason
1961
1962                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1963                                 Custom string
1964
1965                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1966                                 Reconnect bool
1967                         }))(obj)).Custom))))
1968                         write16(w, uint16(x))
1969                 }
1970                 {
1971                         _, err := w.Write(([]byte((*(*(struct {
1972                                 Reason KickReason
1973
1974                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1975                                 Custom string
1976
1977                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1978                                 Reconnect bool
1979                         }))(obj)).Custom))[:])
1980                         chk(err)
1981                 }
1982         }
1983         if dr := (*(*(struct {
1984                 Reason KickReason
1985
1986                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1987                 Custom string
1988
1989                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1990                 Reconnect bool
1991         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1992                 {
1993                         x := (*(*(struct {
1994                                 Reason KickReason
1995
1996                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1997                                 Custom string
1998
1999                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2000                                 Reconnect bool
2001                         }))(obj)).Reconnect
2002                         if x {
2003                                 write8(w, 1)
2004                         } else {
2005                                 write8(w, 0)
2006                         }
2007
2008                 }
2009         }
2010 }
2011
2012 func (obj *ToCltKick) deserialize(r io.Reader) {
2013         if err := pcall(func() {
2014                 ((*(*(struct {
2015                         Reason KickReason
2016
2017                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2018                         Custom string
2019
2020                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2021                         Reconnect bool
2022                 }))(obj)).Reason).deserialize(r)
2023         }); err != nil {
2024                 if err == io.EOF {
2025                         chk(io.EOF)
2026                 }
2027                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.KickReason", err))
2028         }
2029         if !((*(*(struct {
2030                 Reason KickReason
2031
2032                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2033                 Custom string
2034
2035                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2036                 Reconnect bool
2037         }))(obj)).Reason < maxKickReason) {
2038                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2039         }
2040         if dr := (*(*(struct {
2041                 Reason KickReason
2042
2043                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2044                 Custom string
2045
2046                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2047                 Reconnect bool
2048         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2049                 var local60 []uint8
2050                 var local61 uint16
2051                 {
2052                         p := &local61
2053                         *p = read16(r)
2054                 }
2055                 (local60) = make([]uint8, local61)
2056                 {
2057                         _, err := io.ReadFull(r, (local60)[:])
2058                         chk(err)
2059                 }
2060                 ((*(*(struct {
2061                         Reason KickReason
2062
2063                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2064                         Custom string
2065
2066                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2067                         Reconnect bool
2068                 }))(obj)).Custom) = string(local60)
2069         }
2070         if dr := (*(*(struct {
2071                 Reason KickReason
2072
2073                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2074                 Custom string
2075
2076                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2077                 Reconnect bool
2078         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2079                 {
2080                         p := &(*(*(struct {
2081                                 Reason KickReason
2082
2083                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2084                                 Custom string
2085
2086                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2087                                 Reconnect bool
2088                         }))(obj)).Reconnect
2089                         switch n := read8(r); n {
2090                         case 0:
2091                                 *p = false
2092                         case 1:
2093                                 *p = true
2094                         default:
2095                                 chk(fmt.Errorf("invalid bool: %d", n))
2096                         }
2097
2098                 }
2099         }
2100 }
2101
2102 func (obj *ToCltBlkData) serialize(w io.Writer) {
2103         for local62 := range (*(*(struct {
2104                 Blkpos [3]int16
2105                 Blk    MapBlk
2106         }))(obj)).Blkpos {
2107                 {
2108                         x := ((*(*(struct {
2109                                 Blkpos [3]int16
2110                                 Blk    MapBlk
2111                         }))(obj)).Blkpos)[local62]
2112                         write16(w, uint16(x))
2113                 }
2114         }
2115         if err := pcall(func() {
2116                 ((*(*(struct {
2117                         Blkpos [3]int16
2118                         Blk    MapBlk
2119                 }))(obj)).Blk).serialize(w)
2120         }); err != nil {
2121                 if err == io.EOF {
2122                         chk(io.EOF)
2123                 }
2124                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlk", err))
2125         }
2126 }
2127
2128 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2129         for local63 := range (*(*(struct {
2130                 Blkpos [3]int16
2131                 Blk    MapBlk
2132         }))(obj)).Blkpos {
2133                 {
2134                         p := &((*(*(struct {
2135                                 Blkpos [3]int16
2136                                 Blk    MapBlk
2137                         }))(obj)).Blkpos)[local63]
2138                         *p = int16(read16(r))
2139                 }
2140         }
2141         if err := pcall(func() {
2142                 ((*(*(struct {
2143                         Blkpos [3]int16
2144                         Blk    MapBlk
2145                 }))(obj)).Blk).deserialize(r)
2146         }); err != nil {
2147                 if err == io.EOF {
2148                         chk(io.EOF)
2149                 }
2150                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlk", err))
2151         }
2152 }
2153
2154 func (obj *ToCltAddNode) serialize(w io.Writer) {
2155         for local64 := range (*(*(struct {
2156                 Pos [3]int16
2157                 Node
2158                 KeepMeta bool
2159         }))(obj)).Pos {
2160                 {
2161                         x := ((*(*(struct {
2162                                 Pos [3]int16
2163                                 Node
2164                                 KeepMeta bool
2165                         }))(obj)).Pos)[local64]
2166                         write16(w, uint16(x))
2167                 }
2168         }
2169         if err := pcall(func() {
2170                 ((*(*(struct {
2171                         Pos [3]int16
2172                         Node
2173                         KeepMeta bool
2174                 }))(obj)).Node).serialize(w)
2175         }); err != nil {
2176                 if err == io.EOF {
2177                         chk(io.EOF)
2178                 }
2179                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Node", err))
2180         }
2181         {
2182                 x := (*(*(struct {
2183                         Pos [3]int16
2184                         Node
2185                         KeepMeta bool
2186                 }))(obj)).KeepMeta
2187                 if x {
2188                         write8(w, 1)
2189                 } else {
2190                         write8(w, 0)
2191                 }
2192
2193         }
2194 }
2195
2196 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2197         for local65 := range (*(*(struct {
2198                 Pos [3]int16
2199                 Node
2200                 KeepMeta bool
2201         }))(obj)).Pos {
2202                 {
2203                         p := &((*(*(struct {
2204                                 Pos [3]int16
2205                                 Node
2206                                 KeepMeta bool
2207                         }))(obj)).Pos)[local65]
2208                         *p = int16(read16(r))
2209                 }
2210         }
2211         if err := pcall(func() {
2212                 ((*(*(struct {
2213                         Pos [3]int16
2214                         Node
2215                         KeepMeta bool
2216                 }))(obj)).Node).deserialize(r)
2217         }); err != nil {
2218                 if err == io.EOF {
2219                         chk(io.EOF)
2220                 }
2221                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Node", err))
2222         }
2223         {
2224                 p := &(*(*(struct {
2225                         Pos [3]int16
2226                         Node
2227                         KeepMeta bool
2228                 }))(obj)).KeepMeta
2229                 switch n := read8(r); n {
2230                 case 0:
2231                         *p = false
2232                 case 1:
2233                         *p = true
2234                 default:
2235                         chk(fmt.Errorf("invalid bool: %d", n))
2236                 }
2237
2238         }
2239 }
2240
2241 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2242         for local66 := range (*(*(struct {
2243                 Pos [3]int16
2244         }))(obj)).Pos {
2245                 {
2246                         x := ((*(*(struct {
2247                                 Pos [3]int16
2248                         }))(obj)).Pos)[local66]
2249                         write16(w, uint16(x))
2250                 }
2251         }
2252 }
2253
2254 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2255         for local67 := range (*(*(struct {
2256                 Pos [3]int16
2257         }))(obj)).Pos {
2258                 {
2259                         p := &((*(*(struct {
2260                                 Pos [3]int16
2261                         }))(obj)).Pos)[local67]
2262                         *p = int16(read16(r))
2263                 }
2264         }
2265 }
2266
2267 func (obj *ToCltInv) serialize(w io.Writer) {
2268         {
2269                 _, err := w.Write(([]byte((*(*(struct {
2270                         //mt:raw
2271                         Inv string
2272                 }))(obj)).Inv))[:])
2273                 chk(err)
2274         }
2275 }
2276
2277 func (obj *ToCltInv) deserialize(r io.Reader) {
2278         var local68 []uint8
2279         {
2280                 var err error
2281                 (local68), err = io.ReadAll(r)
2282                 chk(err)
2283         }
2284         ((*(*(struct {
2285                 //mt:raw
2286                 Inv string
2287         }))(obj)).Inv) = string(local68)
2288 }
2289
2290 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2291         {
2292                 x := (*(*(struct {
2293                         Time  uint16  // %24000
2294                         Speed float32 // Speed times faster than real time
2295                 }))(obj)).Time
2296                 write16(w, uint16(x))
2297         }
2298         {
2299                 x := (*(*(struct {
2300                         Time  uint16  // %24000
2301                         Speed float32 // Speed times faster than real time
2302                 }))(obj)).Speed
2303                 write32(w, math.Float32bits(x))
2304         }
2305 }
2306
2307 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2308         {
2309                 p := &(*(*(struct {
2310                         Time  uint16  // %24000
2311                         Speed float32 // Speed times faster than real time
2312                 }))(obj)).Time
2313                 *p = read16(r)
2314         }
2315         {
2316                 p := &(*(*(struct {
2317                         Time  uint16  // %24000
2318                         Speed float32 // Speed times faster than real time
2319                 }))(obj)).Speed
2320                 *p = math.Float32frombits(read32(r))
2321         }
2322 }
2323
2324 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2325         if err := pcall(func() {
2326                 ((*(*(struct {
2327                         Flags CSMRestrictionFlags
2328
2329                         // MapRange is the maximum distance from the player CSMs can read the map
2330                         // if Flags&LimitMapRange != 0.
2331                         MapRange uint32
2332                 }))(obj)).Flags).serialize(w)
2333         }); err != nil {
2334                 if err == io.EOF {
2335                         chk(io.EOF)
2336                 }
2337                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CSMRestrictionFlags", err))
2338         }
2339         {
2340                 x := (*(*(struct {
2341                         Flags CSMRestrictionFlags
2342
2343                         // MapRange is the maximum distance from the player CSMs can read the map
2344                         // if Flags&LimitMapRange != 0.
2345                         MapRange uint32
2346                 }))(obj)).MapRange
2347                 write32(w, uint32(x))
2348         }
2349 }
2350
2351 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2352         if err := pcall(func() {
2353                 ((*(*(struct {
2354                         Flags CSMRestrictionFlags
2355
2356                         // MapRange is the maximum distance from the player CSMs can read the map
2357                         // if Flags&LimitMapRange != 0.
2358                         MapRange uint32
2359                 }))(obj)).Flags).deserialize(r)
2360         }); err != nil {
2361                 if err == io.EOF {
2362                         chk(io.EOF)
2363                 }
2364                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.CSMRestrictionFlags", err))
2365         }
2366         {
2367                 p := &(*(*(struct {
2368                         Flags CSMRestrictionFlags
2369
2370                         // MapRange is the maximum distance from the player CSMs can read the map
2371                         // if Flags&LimitMapRange != 0.
2372                         MapRange uint32
2373                 }))(obj)).MapRange
2374                 *p = read32(r)
2375         }
2376 }
2377
2378 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2379         if err := pcall(func() {
2380                 ((*(*(struct {
2381                         Vel Vec
2382                 }))(obj)).Vel).serialize(w)
2383         }); err != nil {
2384                 if err == io.EOF {
2385                         chk(io.EOF)
2386                 }
2387                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
2388         }
2389 }
2390
2391 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2392         if err := pcall(func() {
2393                 ((*(*(struct {
2394                         Vel Vec
2395                 }))(obj)).Vel).deserialize(r)
2396         }); err != nil {
2397                 if err == io.EOF {
2398                         chk(io.EOF)
2399                 }
2400                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
2401         }
2402 }
2403
2404 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2405         if len(([]byte((*(*(struct {
2406                 RawHash       string
2407                 Filename      string
2408                 CallbackToken uint32
2409                 ShouldCache   bool
2410         }))(obj)).RawHash))) > math.MaxUint16 {
2411                 chk(ErrTooLong)
2412         }
2413         {
2414                 x := uint16(len(([]byte((*(*(struct {
2415                         RawHash       string
2416                         Filename      string
2417                         CallbackToken uint32
2418                         ShouldCache   bool
2419                 }))(obj)).RawHash))))
2420                 write16(w, uint16(x))
2421         }
2422         {
2423                 _, err := w.Write(([]byte((*(*(struct {
2424                         RawHash       string
2425                         Filename      string
2426                         CallbackToken uint32
2427                         ShouldCache   bool
2428                 }))(obj)).RawHash))[:])
2429                 chk(err)
2430         }
2431         if len(([]byte((*(*(struct {
2432                 RawHash       string
2433                 Filename      string
2434                 CallbackToken uint32
2435                 ShouldCache   bool
2436         }))(obj)).Filename))) > math.MaxUint16 {
2437                 chk(ErrTooLong)
2438         }
2439         {
2440                 x := uint16(len(([]byte((*(*(struct {
2441                         RawHash       string
2442                         Filename      string
2443                         CallbackToken uint32
2444                         ShouldCache   bool
2445                 }))(obj)).Filename))))
2446                 write16(w, uint16(x))
2447         }
2448         {
2449                 _, err := w.Write(([]byte((*(*(struct {
2450                         RawHash       string
2451                         Filename      string
2452                         CallbackToken uint32
2453                         ShouldCache   bool
2454                 }))(obj)).Filename))[:])
2455                 chk(err)
2456         }
2457         {
2458                 x := (*(*(struct {
2459                         RawHash       string
2460                         Filename      string
2461                         CallbackToken uint32
2462                         ShouldCache   bool
2463                 }))(obj)).CallbackToken
2464                 write32(w, uint32(x))
2465         }
2466         {
2467                 x := (*(*(struct {
2468                         RawHash       string
2469                         Filename      string
2470                         CallbackToken uint32
2471                         ShouldCache   bool
2472                 }))(obj)).ShouldCache
2473                 if x {
2474                         write8(w, 1)
2475                 } else {
2476                         write8(w, 0)
2477                 }
2478
2479         }
2480 }
2481
2482 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2483         var local69 []uint8
2484         var local70 uint16
2485         {
2486                 p := &local70
2487                 *p = read16(r)
2488         }
2489         (local69) = make([]uint8, local70)
2490         {
2491                 _, err := io.ReadFull(r, (local69)[:])
2492                 chk(err)
2493         }
2494         ((*(*(struct {
2495                 RawHash       string
2496                 Filename      string
2497                 CallbackToken uint32
2498                 ShouldCache   bool
2499         }))(obj)).RawHash) = string(local69)
2500         var local71 []uint8
2501         var local72 uint16
2502         {
2503                 p := &local72
2504                 *p = read16(r)
2505         }
2506         (local71) = make([]uint8, local72)
2507         {
2508                 _, err := io.ReadFull(r, (local71)[:])
2509                 chk(err)
2510         }
2511         ((*(*(struct {
2512                 RawHash       string
2513                 Filename      string
2514                 CallbackToken uint32
2515                 ShouldCache   bool
2516         }))(obj)).Filename) = string(local71)
2517         {
2518                 p := &(*(*(struct {
2519                         RawHash       string
2520                         Filename      string
2521                         CallbackToken uint32
2522                         ShouldCache   bool
2523                 }))(obj)).CallbackToken
2524                 *p = read32(r)
2525         }
2526         {
2527                 p := &(*(*(struct {
2528                         RawHash       string
2529                         Filename      string
2530                         CallbackToken uint32
2531                         ShouldCache   bool
2532                 }))(obj)).ShouldCache
2533                 switch n := read8(r); n {
2534                 case 0:
2535                         *p = false
2536                 case 1:
2537                         *p = true
2538                 default:
2539                         chk(fmt.Errorf("invalid bool: %d", n))
2540                 }
2541
2542         }
2543 }
2544
2545 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2546         {
2547                 local73 := uint8(1)
2548                 {
2549                         x := local73
2550                         write8(w, uint8(x))
2551                 }
2552         }
2553         if err := pcall(func() {
2554                 ((*(*(struct {
2555                         Type ChatMsgType
2556
2557                         //mt:utf16
2558                         Sender, Text string
2559
2560                         Timestamp int64 // Unix time.
2561                 }))(obj)).Type).serialize(w)
2562         }); err != nil {
2563                 if err == io.EOF {
2564                         chk(io.EOF)
2565                 }
2566                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ChatMsgType", err))
2567         }
2568         local74 := utf16.Encode([]rune((*(*(struct {
2569                 Type ChatMsgType
2570
2571                 //mt:utf16
2572                 Sender, Text string
2573
2574                 Timestamp int64 // Unix time.
2575         }))(obj)).Sender))
2576         if len((local74)) > math.MaxUint16 {
2577                 chk(ErrTooLong)
2578         }
2579         {
2580                 x := uint16(len((local74)))
2581                 write16(w, uint16(x))
2582         }
2583         for local75 := range local74 {
2584                 {
2585                         x := (local74)[local75]
2586                         write16(w, uint16(x))
2587                 }
2588         }
2589         local76 := utf16.Encode([]rune((*(*(struct {
2590                 Type ChatMsgType
2591
2592                 //mt:utf16
2593                 Sender, Text string
2594
2595                 Timestamp int64 // Unix time.
2596         }))(obj)).Text))
2597         if len((local76)) > math.MaxUint16 {
2598                 chk(ErrTooLong)
2599         }
2600         {
2601                 x := uint16(len((local76)))
2602                 write16(w, uint16(x))
2603         }
2604         for local77 := range local76 {
2605                 {
2606                         x := (local76)[local77]
2607                         write16(w, uint16(x))
2608                 }
2609         }
2610         {
2611                 x := (*(*(struct {
2612                         Type ChatMsgType
2613
2614                         //mt:utf16
2615                         Sender, Text string
2616
2617                         Timestamp int64 // Unix time.
2618                 }))(obj)).Timestamp
2619                 write64(w, uint64(x))
2620
2621         }
2622 }
2623
2624 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2625         {
2626                 var local78 uint8
2627                 local79 := uint8(1)
2628                 {
2629                         p := &local78
2630                         *p = read8(r)
2631                 }
2632                 if local78 != local79 {
2633                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local78))
2634                 }
2635         }
2636         if err := pcall(func() {
2637                 ((*(*(struct {
2638                         Type ChatMsgType
2639
2640                         //mt:utf16
2641                         Sender, Text string
2642
2643                         Timestamp int64 // Unix time.
2644                 }))(obj)).Type).deserialize(r)
2645         }); err != nil {
2646                 if err == io.EOF {
2647                         chk(io.EOF)
2648                 }
2649                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ChatMsgType", err))
2650         }
2651         var local80 []uint16
2652         var local81 uint16
2653         {
2654                 p := &local81
2655                 *p = read16(r)
2656         }
2657         (local80) = make([]uint16, local81)
2658         for local82 := range local80 {
2659                 {
2660                         p := &(local80)[local82]
2661                         *p = read16(r)
2662                 }
2663         }
2664         (*(*(struct {
2665                 Type ChatMsgType
2666
2667                 //mt:utf16
2668                 Sender, Text string
2669
2670                 Timestamp int64 // Unix time.
2671         }))(obj)).Sender = string(utf16.Decode(local80))
2672         var local83 []uint16
2673         var local84 uint16
2674         {
2675                 p := &local84
2676                 *p = read16(r)
2677         }
2678         (local83) = make([]uint16, local84)
2679         for local85 := range local83 {
2680                 {
2681                         p := &(local83)[local85]
2682                         *p = read16(r)
2683                 }
2684         }
2685         (*(*(struct {
2686                 Type ChatMsgType
2687
2688                 //mt:utf16
2689                 Sender, Text string
2690
2691                 Timestamp int64 // Unix time.
2692         }))(obj)).Text = string(utf16.Decode(local83))
2693         {
2694                 p := &(*(*(struct {
2695                         Type ChatMsgType
2696
2697                         //mt:utf16
2698                         Sender, Text string
2699
2700                         Timestamp int64 // Unix time.
2701                 }))(obj)).Timestamp
2702                 *p = int64(read64(r))
2703
2704         }
2705 }
2706
2707 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2708         if len(((*(*(struct {
2709                 Remove []AOID
2710                 Add    []AOAdd
2711         }))(obj)).Remove)) > math.MaxUint16 {
2712                 chk(ErrTooLong)
2713         }
2714         {
2715                 x := uint16(len(((*(*(struct {
2716                         Remove []AOID
2717                         Add    []AOAdd
2718                 }))(obj)).Remove)))
2719                 write16(w, uint16(x))
2720         }
2721         for local86 := range (*(*(struct {
2722                 Remove []AOID
2723                 Add    []AOAdd
2724         }))(obj)).Remove {
2725                 if err := pcall(func() {
2726                         (((*(*(struct {
2727                                 Remove []AOID
2728                                 Add    []AOAdd
2729                         }))(obj)).Remove)[local86]).serialize(w)
2730                 }); err != nil {
2731                         if err == io.EOF {
2732                                 chk(io.EOF)
2733                         }
2734                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
2735                 }
2736         }
2737         if len(((*(*(struct {
2738                 Remove []AOID
2739                 Add    []AOAdd
2740         }))(obj)).Add)) > math.MaxUint16 {
2741                 chk(ErrTooLong)
2742         }
2743         {
2744                 x := uint16(len(((*(*(struct {
2745                         Remove []AOID
2746                         Add    []AOAdd
2747                 }))(obj)).Add)))
2748                 write16(w, uint16(x))
2749         }
2750         for local87 := range (*(*(struct {
2751                 Remove []AOID
2752                 Add    []AOAdd
2753         }))(obj)).Add {
2754                 if err := pcall(func() {
2755                         (((*(*(struct {
2756                                 Remove []AOID
2757                                 Add    []AOAdd
2758                         }))(obj)).Add)[local87]).serialize(w)
2759                 }); err != nil {
2760                         if err == io.EOF {
2761                                 chk(io.EOF)
2762                         }
2763                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAdd", err))
2764                 }
2765         }
2766 }
2767
2768 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2769         var local88 uint16
2770         {
2771                 p := &local88
2772                 *p = read16(r)
2773         }
2774         ((*(*(struct {
2775                 Remove []AOID
2776                 Add    []AOAdd
2777         }))(obj)).Remove) = make([]AOID, local88)
2778         for local89 := range (*(*(struct {
2779                 Remove []AOID
2780                 Add    []AOAdd
2781         }))(obj)).Remove {
2782                 if err := pcall(func() {
2783                         (((*(*(struct {
2784                                 Remove []AOID
2785                                 Add    []AOAdd
2786                         }))(obj)).Remove)[local89]).deserialize(r)
2787                 }); err != nil {
2788                         if err == io.EOF {
2789                                 chk(io.EOF)
2790                         }
2791                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
2792                 }
2793         }
2794         var local90 uint16
2795         {
2796                 p := &local90
2797                 *p = read16(r)
2798         }
2799         ((*(*(struct {
2800                 Remove []AOID
2801                 Add    []AOAdd
2802         }))(obj)).Add) = make([]AOAdd, local90)
2803         for local91 := range (*(*(struct {
2804                 Remove []AOID
2805                 Add    []AOAdd
2806         }))(obj)).Add {
2807                 if err := pcall(func() {
2808                         (((*(*(struct {
2809                                 Remove []AOID
2810                                 Add    []AOAdd
2811                         }))(obj)).Add)[local91]).deserialize(r)
2812                 }); err != nil {
2813                         if err == io.EOF {
2814                                 chk(io.EOF)
2815                         }
2816                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAdd", err))
2817                 }
2818         }
2819 }
2820
2821 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2822         for local92 := range (*(*(struct {
2823                 //mt:raw
2824                 Msgs []IDAOMsg
2825         }))(obj)).Msgs {
2826                 if err := pcall(func() {
2827                         (((*(*(struct {
2828                                 //mt:raw
2829                                 Msgs []IDAOMsg
2830                         }))(obj)).Msgs)[local92]).serialize(w)
2831                 }); err != nil {
2832                         if err == io.EOF {
2833                                 chk(io.EOF)
2834                         }
2835                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.IDAOMsg", err))
2836                 }
2837         }
2838 }
2839
2840 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2841         for {
2842                 var local93 IDAOMsg
2843                 err := pcall(func() {
2844                         if err := pcall(func() {
2845                                 (local93).deserialize(r)
2846                         }); err != nil {
2847                                 if err == io.EOF {
2848                                         chk(io.EOF)
2849                                 }
2850                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.IDAOMsg", err))
2851                         }
2852                 })
2853                 if err == io.EOF {
2854                         break
2855                 }
2856                 ((*(*(struct {
2857                         //mt:raw
2858                         Msgs []IDAOMsg
2859                 }))(obj)).Msgs) = append(((*(*(struct {
2860                         //mt:raw
2861                         Msgs []IDAOMsg
2862                 }))(obj)).Msgs), local93)
2863                 chk(err)
2864         }
2865 }
2866
2867 func (obj *ToCltHP) serialize(w io.Writer) {
2868         {
2869                 x := (*(*(struct {
2870                         HP uint16
2871                 }))(obj)).HP
2872                 write16(w, uint16(x))
2873         }
2874 }
2875
2876 func (obj *ToCltHP) deserialize(r io.Reader) {
2877         {
2878                 p := &(*(*(struct {
2879                         HP uint16
2880                 }))(obj)).HP
2881                 *p = read16(r)
2882         }
2883 }
2884
2885 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2886         if err := pcall(func() {
2887                 ((*(*(struct {
2888                         Pos
2889                         Pitch, Yaw float32
2890                 }))(obj)).Pos).serialize(w)
2891         }); err != nil {
2892                 if err == io.EOF {
2893                         chk(io.EOF)
2894                 }
2895                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
2896         }
2897         {
2898                 x := (*(*(struct {
2899                         Pos
2900                         Pitch, Yaw float32
2901                 }))(obj)).Pitch
2902                 write32(w, math.Float32bits(x))
2903         }
2904         {
2905                 x := (*(*(struct {
2906                         Pos
2907                         Pitch, Yaw float32
2908                 }))(obj)).Yaw
2909                 write32(w, math.Float32bits(x))
2910         }
2911 }
2912
2913 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2914         if err := pcall(func() {
2915                 ((*(*(struct {
2916                         Pos
2917                         Pitch, Yaw float32
2918                 }))(obj)).Pos).deserialize(r)
2919         }); err != nil {
2920                 if err == io.EOF {
2921                         chk(io.EOF)
2922                 }
2923                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
2924         }
2925         {
2926                 p := &(*(*(struct {
2927                         Pos
2928                         Pitch, Yaw float32
2929                 }))(obj)).Pitch
2930                 *p = math.Float32frombits(read32(r))
2931         }
2932         {
2933                 p := &(*(*(struct {
2934                         Pos
2935                         Pitch, Yaw float32
2936                 }))(obj)).Yaw
2937                 *p = math.Float32frombits(read32(r))
2938         }
2939 }
2940
2941 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
2942         local94 := utf16.Encode([]rune((*(*(struct {
2943                 //mt:utf16
2944                 Reason string
2945         }))(obj)).Reason))
2946         if len((local94)) > math.MaxUint16 {
2947                 chk(ErrTooLong)
2948         }
2949         {
2950                 x := uint16(len((local94)))
2951                 write16(w, uint16(x))
2952         }
2953         for local95 := range local94 {
2954                 {
2955                         x := (local94)[local95]
2956                         write16(w, uint16(x))
2957                 }
2958         }
2959 }
2960
2961 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
2962         var local96 []uint16
2963         var local97 uint16
2964         {
2965                 p := &local97
2966                 *p = read16(r)
2967         }
2968         (local96) = make([]uint16, local97)
2969         for local98 := range local96 {
2970                 {
2971                         p := &(local96)[local98]
2972                         *p = read16(r)
2973                 }
2974         }
2975         (*(*(struct {
2976                 //mt:utf16
2977                 Reason string
2978         }))(obj)).Reason = string(utf16.Decode(local96))
2979 }
2980
2981 func (obj *ToCltFOV) serialize(w io.Writer) {
2982         {
2983                 x := (*(*(struct {
2984                         FOV            float32
2985                         Multiplier     bool
2986                         TransitionTime float32
2987                 }))(obj)).FOV
2988                 write32(w, math.Float32bits(x))
2989         }
2990         {
2991                 x := (*(*(struct {
2992                         FOV            float32
2993                         Multiplier     bool
2994                         TransitionTime float32
2995                 }))(obj)).Multiplier
2996                 if x {
2997                         write8(w, 1)
2998                 } else {
2999                         write8(w, 0)
3000                 }
3001
3002         }
3003         {
3004                 x := (*(*(struct {
3005                         FOV            float32
3006                         Multiplier     bool
3007                         TransitionTime float32
3008                 }))(obj)).TransitionTime
3009                 write32(w, math.Float32bits(x))
3010         }
3011 }
3012
3013 func (obj *ToCltFOV) deserialize(r io.Reader) {
3014         {
3015                 p := &(*(*(struct {
3016                         FOV            float32
3017                         Multiplier     bool
3018                         TransitionTime float32
3019                 }))(obj)).FOV
3020                 *p = math.Float32frombits(read32(r))
3021         }
3022         {
3023                 p := &(*(*(struct {
3024                         FOV            float32
3025                         Multiplier     bool
3026                         TransitionTime float32
3027                 }))(obj)).Multiplier
3028                 switch n := read8(r); n {
3029                 case 0:
3030                         *p = false
3031                 case 1:
3032                         *p = true
3033                 default:
3034                         chk(fmt.Errorf("invalid bool: %d", n))
3035                 }
3036
3037         }
3038         {
3039                 p := &(*(*(struct {
3040                         FOV            float32
3041                         Multiplier     bool
3042                         TransitionTime float32
3043                 }))(obj)).TransitionTime
3044                 *p = math.Float32frombits(read32(r))
3045         }
3046 }
3047
3048 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3049         {
3050                 x := (*(*(struct {
3051                         PointCam bool
3052                         PointAt  Pos
3053                 }))(obj)).PointCam
3054                 if x {
3055                         write8(w, 1)
3056                 } else {
3057                         write8(w, 0)
3058                 }
3059
3060         }
3061         if err := pcall(func() {
3062                 ((*(*(struct {
3063                         PointCam bool
3064                         PointAt  Pos
3065                 }))(obj)).PointAt).serialize(w)
3066         }); err != nil {
3067                 if err == io.EOF {
3068                         chk(io.EOF)
3069                 }
3070                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
3071         }
3072 }
3073
3074 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3075         {
3076                 p := &(*(*(struct {
3077                         PointCam bool
3078                         PointAt  Pos
3079                 }))(obj)).PointCam
3080                 switch n := read8(r); n {
3081                 case 0:
3082                         *p = false
3083                 case 1:
3084                         *p = true
3085                 default:
3086                         chk(fmt.Errorf("invalid bool: %d", n))
3087                 }
3088
3089         }
3090         if err := pcall(func() {
3091                 ((*(*(struct {
3092                         PointCam bool
3093                         PointAt  Pos
3094                 }))(obj)).PointAt).deserialize(r)
3095         }); err != nil {
3096                 if err == io.EOF {
3097                         chk(io.EOF)
3098                 }
3099                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
3100         }
3101 }
3102
3103 func (obj *ToCltMedia) serialize(w io.Writer) {
3104         {
3105                 x := (*(*(struct {
3106                         // N is the total number of ToCltMedia packets.
3107                         // I is the index of this packet.
3108                         N, I uint16
3109
3110                         //mt:len32
3111                         Files []struct {
3112                                 Name string
3113
3114                                 //mt:len32
3115                                 Data []byte
3116                         }
3117                 }))(obj)).N
3118                 write16(w, uint16(x))
3119         }
3120         {
3121                 x := (*(*(struct {
3122                         // N is the total number of ToCltMedia packets.
3123                         // I is the index of this packet.
3124                         N, I uint16
3125
3126                         //mt:len32
3127                         Files []struct {
3128                                 Name string
3129
3130                                 //mt:len32
3131                                 Data []byte
3132                         }
3133                 }))(obj)).I
3134                 write16(w, uint16(x))
3135         }
3136         if len(((*(*(struct {
3137                 // N is the total number of ToCltMedia packets.
3138                 // I is the index of this packet.
3139                 N, I uint16
3140
3141                 //mt:len32
3142                 Files []struct {
3143                         Name string
3144
3145                         //mt:len32
3146                         Data []byte
3147                 }
3148         }))(obj)).Files)) > math.MaxUint32 {
3149                 chk(ErrTooLong)
3150         }
3151         {
3152                 x := uint32(len(((*(*(struct {
3153                         // N is the total number of ToCltMedia packets.
3154                         // I is the index of this packet.
3155                         N, I uint16
3156
3157                         //mt:len32
3158                         Files []struct {
3159                                 Name string
3160
3161                                 //mt:len32
3162                                 Data []byte
3163                         }
3164                 }))(obj)).Files)))
3165                 write32(w, uint32(x))
3166         }
3167         for local99 := range (*(*(struct {
3168                 // N is the total number of ToCltMedia packets.
3169                 // I is the index of this packet.
3170                 N, I uint16
3171
3172                 //mt:len32
3173                 Files []struct {
3174                         Name string
3175
3176                         //mt:len32
3177                         Data []byte
3178                 }
3179         }))(obj)).Files {
3180                 if len(([]byte((((*(*(struct {
3181                         // N is the total number of ToCltMedia packets.
3182                         // I is the index of this packet.
3183                         N, I uint16
3184
3185                         //mt:len32
3186                         Files []struct {
3187                                 Name string
3188
3189                                 //mt:len32
3190                                 Data []byte
3191                         }
3192                 }))(obj)).Files)[local99]).Name))) > math.MaxUint16 {
3193                         chk(ErrTooLong)
3194                 }
3195                 {
3196                         x := uint16(len(([]byte((((*(*(struct {
3197                                 // N is the total number of ToCltMedia packets.
3198                                 // I is the index of this packet.
3199                                 N, I uint16
3200
3201                                 //mt:len32
3202                                 Files []struct {
3203                                         Name string
3204
3205                                         //mt:len32
3206                                         Data []byte
3207                                 }
3208                         }))(obj)).Files)[local99]).Name))))
3209                         write16(w, uint16(x))
3210                 }
3211                 {
3212                         _, err := w.Write(([]byte((((*(*(struct {
3213                                 // N is the total number of ToCltMedia packets.
3214                                 // I is the index of this packet.
3215                                 N, I uint16
3216
3217                                 //mt:len32
3218                                 Files []struct {
3219                                         Name string
3220
3221                                         //mt:len32
3222                                         Data []byte
3223                                 }
3224                         }))(obj)).Files)[local99]).Name))[:])
3225                         chk(err)
3226                 }
3227                 if len(((((*(*(struct {
3228                         // N is the total number of ToCltMedia packets.
3229                         // I is the index of this packet.
3230                         N, I uint16
3231
3232                         //mt:len32
3233                         Files []struct {
3234                                 Name string
3235
3236                                 //mt:len32
3237                                 Data []byte
3238                         }
3239                 }))(obj)).Files)[local99]).Data)) > math.MaxUint32 {
3240                         chk(ErrTooLong)
3241                 }
3242                 {
3243                         x := uint32(len(((((*(*(struct {
3244                                 // N is the total number of ToCltMedia packets.
3245                                 // I is the index of this packet.
3246                                 N, I uint16
3247
3248                                 //mt:len32
3249                                 Files []struct {
3250                                         Name string
3251
3252                                         //mt:len32
3253                                         Data []byte
3254                                 }
3255                         }))(obj)).Files)[local99]).Data)))
3256                         write32(w, uint32(x))
3257                 }
3258                 {
3259                         _, err := w.Write(((((*(*(struct {
3260                                 // N is the total number of ToCltMedia packets.
3261                                 // I is the index of this packet.
3262                                 N, I uint16
3263
3264                                 //mt:len32
3265                                 Files []struct {
3266                                         Name string
3267
3268                                         //mt:len32
3269                                         Data []byte
3270                                 }
3271                         }))(obj)).Files)[local99]).Data)[:])
3272                         chk(err)
3273                 }
3274         }
3275 }
3276
3277 func (obj *ToCltMedia) deserialize(r io.Reader) {
3278         {
3279                 p := &(*(*(struct {
3280                         // N is the total number of ToCltMedia packets.
3281                         // I is the index of this packet.
3282                         N, I uint16
3283
3284                         //mt:len32
3285                         Files []struct {
3286                                 Name string
3287
3288                                 //mt:len32
3289                                 Data []byte
3290                         }
3291                 }))(obj)).N
3292                 *p = read16(r)
3293         }
3294         {
3295                 p := &(*(*(struct {
3296                         // N is the total number of ToCltMedia packets.
3297                         // I is the index of this packet.
3298                         N, I uint16
3299
3300                         //mt:len32
3301                         Files []struct {
3302                                 Name string
3303
3304                                 //mt:len32
3305                                 Data []byte
3306                         }
3307                 }))(obj)).I
3308                 *p = read16(r)
3309         }
3310         var local100 uint32
3311         {
3312                 p := &local100
3313                 *p = read32(r)
3314         }
3315         ((*(*(struct {
3316                 // N is the total number of ToCltMedia packets.
3317                 // I is the index of this packet.
3318                 N, I uint16
3319
3320                 //mt:len32
3321                 Files []struct {
3322                         Name string
3323
3324                         //mt:len32
3325                         Data []byte
3326                 }
3327         }))(obj)).Files) = make([]struct {
3328                 Name string
3329                 Data []byte
3330         }, local100)
3331         for local101 := range (*(*(struct {
3332                 // N is the total number of ToCltMedia packets.
3333                 // I is the index of this packet.
3334                 N, I uint16
3335
3336                 //mt:len32
3337                 Files []struct {
3338                         Name string
3339
3340                         //mt:len32
3341                         Data []byte
3342                 }
3343         }))(obj)).Files {
3344                 var local102 []uint8
3345                 var local103 uint16
3346                 {
3347                         p := &local103
3348                         *p = read16(r)
3349                 }
3350                 (local102) = make([]uint8, local103)
3351                 {
3352                         _, err := io.ReadFull(r, (local102)[:])
3353                         chk(err)
3354                 }
3355                 ((((*(*(struct {
3356                         // N is the total number of ToCltMedia packets.
3357                         // I is the index of this packet.
3358                         N, I uint16
3359
3360                         //mt:len32
3361                         Files []struct {
3362                                 Name string
3363
3364                                 //mt:len32
3365                                 Data []byte
3366                         }
3367                 }))(obj)).Files)[local101]).Name) = string(local102)
3368                 var local104 uint32
3369                 {
3370                         p := &local104
3371                         *p = read32(r)
3372                 }
3373                 ((((*(*(struct {
3374                         // N is the total number of ToCltMedia packets.
3375                         // I is the index of this packet.
3376                         N, I uint16
3377
3378                         //mt:len32
3379                         Files []struct {
3380                                 Name string
3381
3382                                 //mt:len32
3383                                 Data []byte
3384                         }
3385                 }))(obj)).Files)[local101]).Data) = make([]byte, local104)
3386                 {
3387                         _, err := io.ReadFull(r, ((((*(*(struct {
3388                                 // N is the total number of ToCltMedia packets.
3389                                 // I is the index of this packet.
3390                                 N, I uint16
3391
3392                                 //mt:len32
3393                                 Files []struct {
3394                                         Name string
3395
3396                                         //mt:len32
3397                                         Data []byte
3398                                 }
3399                         }))(obj)).Files)[local101]).Data)[:])
3400                         chk(err)
3401                 }
3402         }
3403 }
3404
3405 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3406         {
3407                 ow := w
3408                 w := new(bytes.Buffer)
3409                 {
3410                         w := zlib.NewWriter(w)
3411                         {
3412                                 local105 := uint8(1)
3413                                 {
3414                                         x := local105
3415                                         write8(w, uint8(x))
3416                                 }
3417                         }
3418                         {
3419                                 x := (*(*(struct {
3420
3421                                         // See (de)serialize.fmt.
3422                                         Defs []NodeDef
3423                                 }))(obj)).Defs
3424                                 { // For ToCltNodeDefs.Defs.
3425                                         if len(x) > math.MaxUint16 {
3426                                                 chk(ErrTooLong)
3427                                         }
3428                                         write16(w, uint16(len(x)))
3429                                         var b bytes.Buffer
3430                                         for i := range x {
3431                                                 x[i].serialize(&b)
3432                                         }
3433                                         if b.Len() > math.MaxUint32 {
3434                                                 chk(ErrTooLong)
3435                                         }
3436                                         write32(w, uint32(b.Len()))
3437                                         _, err := b.WriteTo(w)
3438                                         chk(err)
3439                                 }
3440                         }
3441                         chk(w.Close())
3442                 }
3443                 {
3444                         buf := w
3445                         w := ow
3446                         if len((buf.Bytes())) > math.MaxUint32 {
3447                                 chk(ErrTooLong)
3448                         }
3449                         {
3450                                 x := uint32(len((buf.Bytes())))
3451                                 write32(w, uint32(x))
3452                         }
3453                         {
3454                                 _, err := w.Write((buf.Bytes())[:])
3455                                 chk(err)
3456                         }
3457                 }
3458         }
3459 }
3460
3461 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3462         {
3463                 var n uint32
3464                 {
3465                         p := &n
3466                         *p = read32(r)
3467                 }
3468                 r := &io.LimitedReader{R: r, N: int64(n)}
3469                 {
3470                         r, err := zlib.NewReader(byteReader{r})
3471                         chk(err)
3472                         {
3473                                 var local106 uint8
3474                                 local107 := uint8(1)
3475                                 {
3476                                         p := &local106
3477                                         *p = read8(r)
3478                                 }
3479                                 if local106 != local107 {
3480                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
3481                                 }
3482                         }
3483                         {
3484                                 p := &(*(*(struct {
3485
3486                                         // See (de)serialize.fmt.
3487                                         Defs []NodeDef
3488                                 }))(obj)).Defs
3489                                 { // For ToCltNodeDefs.Defs.
3490                                         *p = make([]NodeDef, read16(r))
3491                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3492                                         for i := range *p {
3493                                                 (*p)[i].deserialize(r)
3494                                         }
3495                                         if r.N > 0 {
3496                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3497                                         }
3498                                 }
3499                         }
3500                         chk(r.Close())
3501                 }
3502                 if r.N > 0 {
3503                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3504                 }
3505         }
3506 }
3507
3508 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3509         if len(((*(*(struct {
3510                 Files []struct {
3511                         Name       string
3512                         Base64SHA1 string
3513                 }
3514                 URL string
3515         }))(obj)).Files)) > math.MaxUint16 {
3516                 chk(ErrTooLong)
3517         }
3518         {
3519                 x := uint16(len(((*(*(struct {
3520                         Files []struct {
3521                                 Name       string
3522                                 Base64SHA1 string
3523                         }
3524                         URL string
3525                 }))(obj)).Files)))
3526                 write16(w, uint16(x))
3527         }
3528         for local108 := range (*(*(struct {
3529                 Files []struct {
3530                         Name       string
3531                         Base64SHA1 string
3532                 }
3533                 URL string
3534         }))(obj)).Files {
3535                 if len(([]byte((((*(*(struct {
3536                         Files []struct {
3537                                 Name       string
3538                                 Base64SHA1 string
3539                         }
3540                         URL string
3541                 }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
3542                         chk(ErrTooLong)
3543                 }
3544                 {
3545                         x := uint16(len(([]byte((((*(*(struct {
3546                                 Files []struct {
3547                                         Name       string
3548                                         Base64SHA1 string
3549                                 }
3550                                 URL string
3551                         }))(obj)).Files)[local108]).Name))))
3552                         write16(w, uint16(x))
3553                 }
3554                 {
3555                         _, err := w.Write(([]byte((((*(*(struct {
3556                                 Files []struct {
3557                                         Name       string
3558                                         Base64SHA1 string
3559                                 }
3560                                 URL string
3561                         }))(obj)).Files)[local108]).Name))[:])
3562                         chk(err)
3563                 }
3564                 if len(([]byte((((*(*(struct {
3565                         Files []struct {
3566                                 Name       string
3567                                 Base64SHA1 string
3568                         }
3569                         URL string
3570                 }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
3571                         chk(ErrTooLong)
3572                 }
3573                 {
3574                         x := uint16(len(([]byte((((*(*(struct {
3575                                 Files []struct {
3576                                         Name       string
3577                                         Base64SHA1 string
3578                                 }
3579                                 URL string
3580                         }))(obj)).Files)[local108]).Base64SHA1))))
3581                         write16(w, uint16(x))
3582                 }
3583                 {
3584                         _, err := w.Write(([]byte((((*(*(struct {
3585                                 Files []struct {
3586                                         Name       string
3587                                         Base64SHA1 string
3588                                 }
3589                                 URL string
3590                         }))(obj)).Files)[local108]).Base64SHA1))[:])
3591                         chk(err)
3592                 }
3593         }
3594         if len(([]byte((*(*(struct {
3595                 Files []struct {
3596                         Name       string
3597                         Base64SHA1 string
3598                 }
3599                 URL string
3600         }))(obj)).URL))) > math.MaxUint16 {
3601                 chk(ErrTooLong)
3602         }
3603         {
3604                 x := uint16(len(([]byte((*(*(struct {
3605                         Files []struct {
3606                                 Name       string
3607                                 Base64SHA1 string
3608                         }
3609                         URL string
3610                 }))(obj)).URL))))
3611                 write16(w, uint16(x))
3612         }
3613         {
3614                 _, err := w.Write(([]byte((*(*(struct {
3615                         Files []struct {
3616                                 Name       string
3617                                 Base64SHA1 string
3618                         }
3619                         URL string
3620                 }))(obj)).URL))[:])
3621                 chk(err)
3622         }
3623 }
3624
3625 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3626         var local109 uint16
3627         {
3628                 p := &local109
3629                 *p = read16(r)
3630         }
3631         ((*(*(struct {
3632                 Files []struct {
3633                         Name       string
3634                         Base64SHA1 string
3635                 }
3636                 URL string
3637         }))(obj)).Files) = make([]struct {
3638                 Name       string
3639                 Base64SHA1 string
3640         }, local109)
3641         for local110 := range (*(*(struct {
3642                 Files []struct {
3643                         Name       string
3644                         Base64SHA1 string
3645                 }
3646                 URL string
3647         }))(obj)).Files {
3648                 var local111 []uint8
3649                 var local112 uint16
3650                 {
3651                         p := &local112
3652                         *p = read16(r)
3653                 }
3654                 (local111) = make([]uint8, local112)
3655                 {
3656                         _, err := io.ReadFull(r, (local111)[:])
3657                         chk(err)
3658                 }
3659                 ((((*(*(struct {
3660                         Files []struct {
3661                                 Name       string
3662                                 Base64SHA1 string
3663                         }
3664                         URL string
3665                 }))(obj)).Files)[local110]).Name) = string(local111)
3666                 var local113 []uint8
3667                 var local114 uint16
3668                 {
3669                         p := &local114
3670                         *p = read16(r)
3671                 }
3672                 (local113) = make([]uint8, local114)
3673                 {
3674                         _, err := io.ReadFull(r, (local113)[:])
3675                         chk(err)
3676                 }
3677                 ((((*(*(struct {
3678                         Files []struct {
3679                                 Name       string
3680                                 Base64SHA1 string
3681                         }
3682                         URL string
3683                 }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
3684         }
3685         var local115 []uint8
3686         var local116 uint16
3687         {
3688                 p := &local116
3689                 *p = read16(r)
3690         }
3691         (local115) = make([]uint8, local116)
3692         {
3693                 _, err := io.ReadFull(r, (local115)[:])
3694                 chk(err)
3695         }
3696         ((*(*(struct {
3697                 Files []struct {
3698                         Name       string
3699                         Base64SHA1 string
3700                 }
3701                 URL string
3702         }))(obj)).URL) = string(local115)
3703 }
3704
3705 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3706         {
3707                 ow := w
3708                 w := new(bytes.Buffer)
3709                 {
3710                         w := zlib.NewWriter(w)
3711                         {
3712                                 local117 := uint8(0)
3713                                 {
3714                                         x := local117
3715                                         write8(w, uint8(x))
3716                                 }
3717                         }
3718                         if len(((*(*(struct {
3719                                 Defs    []ItemDef
3720                                 Aliases []struct{ Alias, Orig string }
3721                         }))(obj)).Defs)) > math.MaxUint16 {
3722                                 chk(ErrTooLong)
3723                         }
3724                         {
3725                                 x := uint16(len(((*(*(struct {
3726                                         Defs    []ItemDef
3727                                         Aliases []struct{ Alias, Orig string }
3728                                 }))(obj)).Defs)))
3729                                 write16(w, uint16(x))
3730                         }
3731                         for local118 := range (*(*(struct {
3732                                 Defs    []ItemDef
3733                                 Aliases []struct{ Alias, Orig string }
3734                         }))(obj)).Defs {
3735                                 if err := pcall(func() {
3736                                         (((*(*(struct {
3737                                                 Defs    []ItemDef
3738                                                 Aliases []struct{ Alias, Orig string }
3739                                         }))(obj)).Defs)[local118]).serialize(w)
3740                                 }); err != nil {
3741                                         if err == io.EOF {
3742                                                 chk(io.EOF)
3743                                         }
3744                                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemDef", err))
3745                                 }
3746                         }
3747                         if len(((*(*(struct {
3748                                 Defs    []ItemDef
3749                                 Aliases []struct{ Alias, Orig string }
3750                         }))(obj)).Aliases)) > math.MaxUint16 {
3751                                 chk(ErrTooLong)
3752                         }
3753                         {
3754                                 x := uint16(len(((*(*(struct {
3755                                         Defs    []ItemDef
3756                                         Aliases []struct{ Alias, Orig string }
3757                                 }))(obj)).Aliases)))
3758                                 write16(w, uint16(x))
3759                         }
3760                         for local119 := range (*(*(struct {
3761                                 Defs    []ItemDef
3762                                 Aliases []struct{ Alias, Orig string }
3763                         }))(obj)).Aliases {
3764                                 if len(([]byte((((*(*(struct {
3765                                         Defs    []ItemDef
3766                                         Aliases []struct{ Alias, Orig string }
3767                                 }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
3768                                         chk(ErrTooLong)
3769                                 }
3770                                 {
3771                                         x := uint16(len(([]byte((((*(*(struct {
3772                                                 Defs    []ItemDef
3773                                                 Aliases []struct{ Alias, Orig string }
3774                                         }))(obj)).Aliases)[local119]).Alias))))
3775                                         write16(w, uint16(x))
3776                                 }
3777                                 {
3778                                         _, err := w.Write(([]byte((((*(*(struct {
3779                                                 Defs    []ItemDef
3780                                                 Aliases []struct{ Alias, Orig string }
3781                                         }))(obj)).Aliases)[local119]).Alias))[:])
3782                                         chk(err)
3783                                 }
3784                                 if len(([]byte((((*(*(struct {
3785                                         Defs    []ItemDef
3786                                         Aliases []struct{ Alias, Orig string }
3787                                 }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
3788                                         chk(ErrTooLong)
3789                                 }
3790                                 {
3791                                         x := uint16(len(([]byte((((*(*(struct {
3792                                                 Defs    []ItemDef
3793                                                 Aliases []struct{ Alias, Orig string }
3794                                         }))(obj)).Aliases)[local119]).Orig))))
3795                                         write16(w, uint16(x))
3796                                 }
3797                                 {
3798                                         _, err := w.Write(([]byte((((*(*(struct {
3799                                                 Defs    []ItemDef
3800                                                 Aliases []struct{ Alias, Orig string }
3801                                         }))(obj)).Aliases)[local119]).Orig))[:])
3802                                         chk(err)
3803                                 }
3804                         }
3805                         chk(w.Close())
3806                 }
3807                 {
3808                         buf := w
3809                         w := ow
3810                         if len((buf.Bytes())) > math.MaxUint32 {
3811                                 chk(ErrTooLong)
3812                         }
3813                         {
3814                                 x := uint32(len((buf.Bytes())))
3815                                 write32(w, uint32(x))
3816                         }
3817                         {
3818                                 _, err := w.Write((buf.Bytes())[:])
3819                                 chk(err)
3820                         }
3821                 }
3822         }
3823 }
3824
3825 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3826         {
3827                 var n uint32
3828                 {
3829                         p := &n
3830                         *p = read32(r)
3831                 }
3832                 r := &io.LimitedReader{R: r, N: int64(n)}
3833                 {
3834                         r, err := zlib.NewReader(byteReader{r})
3835                         chk(err)
3836                         {
3837                                 var local120 uint8
3838                                 local121 := uint8(0)
3839                                 {
3840                                         p := &local120
3841                                         *p = read8(r)
3842                                 }
3843                                 if local120 != local121 {
3844                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
3845                                 }
3846                         }
3847                         var local122 uint16
3848                         {
3849                                 p := &local122
3850                                 *p = read16(r)
3851                         }
3852                         ((*(*(struct {
3853                                 Defs    []ItemDef
3854                                 Aliases []struct{ Alias, Orig string }
3855                         }))(obj)).Defs) = make([]ItemDef, local122)
3856                         for local123 := range (*(*(struct {
3857                                 Defs    []ItemDef
3858                                 Aliases []struct{ Alias, Orig string }
3859                         }))(obj)).Defs {
3860                                 if err := pcall(func() {
3861                                         (((*(*(struct {
3862                                                 Defs    []ItemDef
3863                                                 Aliases []struct{ Alias, Orig string }
3864                                         }))(obj)).Defs)[local123]).deserialize(r)
3865                                 }); err != nil {
3866                                         if err == io.EOF {
3867                                                 chk(io.EOF)
3868                                         }
3869                                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemDef", err))
3870                                 }
3871                         }
3872                         var local124 uint16
3873                         {
3874                                 p := &local124
3875                                 *p = read16(r)
3876                         }
3877                         ((*(*(struct {
3878                                 Defs    []ItemDef
3879                                 Aliases []struct{ Alias, Orig string }
3880                         }))(obj)).Aliases) = make([]struct {
3881                                 Alias string
3882                                 Orig  string
3883                         }, local124)
3884                         for local125 := range (*(*(struct {
3885                                 Defs    []ItemDef
3886                                 Aliases []struct{ Alias, Orig string }
3887                         }))(obj)).Aliases {
3888                                 var local126 []uint8
3889                                 var local127 uint16
3890                                 {
3891                                         p := &local127
3892                                         *p = read16(r)
3893                                 }
3894                                 (local126) = make([]uint8, local127)
3895                                 {
3896                                         _, err := io.ReadFull(r, (local126)[:])
3897                                         chk(err)
3898                                 }
3899                                 ((((*(*(struct {
3900                                         Defs    []ItemDef
3901                                         Aliases []struct{ Alias, Orig string }
3902                                 }))(obj)).Aliases)[local125]).Alias) = string(local126)
3903                                 var local128 []uint8
3904                                 var local129 uint16
3905                                 {
3906                                         p := &local129
3907                                         *p = read16(r)
3908                                 }
3909                                 (local128) = make([]uint8, local129)
3910                                 {
3911                                         _, err := io.ReadFull(r, (local128)[:])
3912                                         chk(err)
3913                                 }
3914                                 ((((*(*(struct {
3915                                         Defs    []ItemDef
3916                                         Aliases []struct{ Alias, Orig string }
3917                                 }))(obj)).Aliases)[local125]).Orig) = string(local128)
3918                         }
3919                         chk(r.Close())
3920                 }
3921                 if r.N > 0 {
3922                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3923                 }
3924         }
3925 }
3926
3927 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3928         if err := pcall(func() {
3929                 ((*(*(struct {
3930                         ID      SoundID
3931                         Name    string
3932                         Gain    float32
3933                         SrcType SoundSrcType
3934                         Pos
3935                         SrcAOID   AOID
3936                         Loop      bool
3937                         Fade      float32
3938                         Pitch     float32
3939                         Ephemeral bool
3940                 }))(obj)).ID).serialize(w)
3941         }); err != nil {
3942                 if err == io.EOF {
3943                         chk(io.EOF)
3944                 }
3945                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
3946         }
3947         if len(([]byte((*(*(struct {
3948                 ID      SoundID
3949                 Name    string
3950                 Gain    float32
3951                 SrcType SoundSrcType
3952                 Pos
3953                 SrcAOID   AOID
3954                 Loop      bool
3955                 Fade      float32
3956                 Pitch     float32
3957                 Ephemeral bool
3958         }))(obj)).Name))) > math.MaxUint16 {
3959                 chk(ErrTooLong)
3960         }
3961         {
3962                 x := uint16(len(([]byte((*(*(struct {
3963                         ID      SoundID
3964                         Name    string
3965                         Gain    float32
3966                         SrcType SoundSrcType
3967                         Pos
3968                         SrcAOID   AOID
3969                         Loop      bool
3970                         Fade      float32
3971                         Pitch     float32
3972                         Ephemeral bool
3973                 }))(obj)).Name))))
3974                 write16(w, uint16(x))
3975         }
3976         {
3977                 _, err := w.Write(([]byte((*(*(struct {
3978                         ID      SoundID
3979                         Name    string
3980                         Gain    float32
3981                         SrcType SoundSrcType
3982                         Pos
3983                         SrcAOID   AOID
3984                         Loop      bool
3985                         Fade      float32
3986                         Pitch     float32
3987                         Ephemeral bool
3988                 }))(obj)).Name))[:])
3989                 chk(err)
3990         }
3991         {
3992                 x := (*(*(struct {
3993                         ID      SoundID
3994                         Name    string
3995                         Gain    float32
3996                         SrcType SoundSrcType
3997                         Pos
3998                         SrcAOID   AOID
3999                         Loop      bool
4000                         Fade      float32
4001                         Pitch     float32
4002                         Ephemeral bool
4003                 }))(obj)).Gain
4004                 write32(w, math.Float32bits(x))
4005         }
4006         if err := pcall(func() {
4007                 ((*(*(struct {
4008                         ID      SoundID
4009                         Name    string
4010                         Gain    float32
4011                         SrcType SoundSrcType
4012                         Pos
4013                         SrcAOID   AOID
4014                         Loop      bool
4015                         Fade      float32
4016                         Pitch     float32
4017                         Ephemeral bool
4018                 }))(obj)).SrcType).serialize(w)
4019         }); err != nil {
4020                 if err == io.EOF {
4021                         chk(io.EOF)
4022                 }
4023                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundSrcType", err))
4024         }
4025         if err := pcall(func() {
4026                 ((*(*(struct {
4027                         ID      SoundID
4028                         Name    string
4029                         Gain    float32
4030                         SrcType SoundSrcType
4031                         Pos
4032                         SrcAOID   AOID
4033                         Loop      bool
4034                         Fade      float32
4035                         Pitch     float32
4036                         Ephemeral bool
4037                 }))(obj)).Pos).serialize(w)
4038         }); err != nil {
4039                 if err == io.EOF {
4040                         chk(io.EOF)
4041                 }
4042                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
4043         }
4044         if err := pcall(func() {
4045                 ((*(*(struct {
4046                         ID      SoundID
4047                         Name    string
4048                         Gain    float32
4049                         SrcType SoundSrcType
4050                         Pos
4051                         SrcAOID   AOID
4052                         Loop      bool
4053                         Fade      float32
4054                         Pitch     float32
4055                         Ephemeral bool
4056                 }))(obj)).SrcAOID).serialize(w)
4057         }); err != nil {
4058                 if err == io.EOF {
4059                         chk(io.EOF)
4060                 }
4061                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
4062         }
4063         {
4064                 x := (*(*(struct {
4065                         ID      SoundID
4066                         Name    string
4067                         Gain    float32
4068                         SrcType SoundSrcType
4069                         Pos
4070                         SrcAOID   AOID
4071                         Loop      bool
4072                         Fade      float32
4073                         Pitch     float32
4074                         Ephemeral bool
4075                 }))(obj)).Loop
4076                 if x {
4077                         write8(w, 1)
4078                 } else {
4079                         write8(w, 0)
4080                 }
4081
4082         }
4083         {
4084                 x := (*(*(struct {
4085                         ID      SoundID
4086                         Name    string
4087                         Gain    float32
4088                         SrcType SoundSrcType
4089                         Pos
4090                         SrcAOID   AOID
4091                         Loop      bool
4092                         Fade      float32
4093                         Pitch     float32
4094                         Ephemeral bool
4095                 }))(obj)).Fade
4096                 write32(w, math.Float32bits(x))
4097         }
4098         {
4099                 x := (*(*(struct {
4100                         ID      SoundID
4101                         Name    string
4102                         Gain    float32
4103                         SrcType SoundSrcType
4104                         Pos
4105                         SrcAOID   AOID
4106                         Loop      bool
4107                         Fade      float32
4108                         Pitch     float32
4109                         Ephemeral bool
4110                 }))(obj)).Pitch
4111                 write32(w, math.Float32bits(x))
4112         }
4113         {
4114                 x := (*(*(struct {
4115                         ID      SoundID
4116                         Name    string
4117                         Gain    float32
4118                         SrcType SoundSrcType
4119                         Pos
4120                         SrcAOID   AOID
4121                         Loop      bool
4122                         Fade      float32
4123                         Pitch     float32
4124                         Ephemeral bool
4125                 }))(obj)).Ephemeral
4126                 if x {
4127                         write8(w, 1)
4128                 } else {
4129                         write8(w, 0)
4130                 }
4131
4132         }
4133 }
4134
4135 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4136         if err := pcall(func() {
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)).ID).deserialize(r)
4149         }); err != nil {
4150                 if err == io.EOF {
4151                         chk(io.EOF)
4152                 }
4153                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
4154         }
4155         var local130 []uint8
4156         var local131 uint16
4157         {
4158                 p := &local131
4159                 *p = read16(r)
4160         }
4161         (local130) = make([]uint8, local131)
4162         {
4163                 _, err := io.ReadFull(r, (local130)[:])
4164                 chk(err)
4165         }
4166         ((*(*(struct {
4167                 ID      SoundID
4168                 Name    string
4169                 Gain    float32
4170                 SrcType SoundSrcType
4171                 Pos
4172                 SrcAOID   AOID
4173                 Loop      bool
4174                 Fade      float32
4175                 Pitch     float32
4176                 Ephemeral bool
4177         }))(obj)).Name) = string(local130)
4178         {
4179                 p := &(*(*(struct {
4180                         ID      SoundID
4181                         Name    string
4182                         Gain    float32
4183                         SrcType SoundSrcType
4184                         Pos
4185                         SrcAOID   AOID
4186                         Loop      bool
4187                         Fade      float32
4188                         Pitch     float32
4189                         Ephemeral bool
4190                 }))(obj)).Gain
4191                 *p = math.Float32frombits(read32(r))
4192         }
4193         if err := pcall(func() {
4194                 ((*(*(struct {
4195                         ID      SoundID
4196                         Name    string
4197                         Gain    float32
4198                         SrcType SoundSrcType
4199                         Pos
4200                         SrcAOID   AOID
4201                         Loop      bool
4202                         Fade      float32
4203                         Pitch     float32
4204                         Ephemeral bool
4205                 }))(obj)).SrcType).deserialize(r)
4206         }); err != nil {
4207                 if err == io.EOF {
4208                         chk(io.EOF)
4209                 }
4210                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundSrcType", err))
4211         }
4212         if err := pcall(func() {
4213                 ((*(*(struct {
4214                         ID      SoundID
4215                         Name    string
4216                         Gain    float32
4217                         SrcType SoundSrcType
4218                         Pos
4219                         SrcAOID   AOID
4220                         Loop      bool
4221                         Fade      float32
4222                         Pitch     float32
4223                         Ephemeral bool
4224                 }))(obj)).Pos).deserialize(r)
4225         }); err != nil {
4226                 if err == io.EOF {
4227                         chk(io.EOF)
4228                 }
4229                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
4230         }
4231         if err := pcall(func() {
4232                 ((*(*(struct {
4233                         ID      SoundID
4234                         Name    string
4235                         Gain    float32
4236                         SrcType SoundSrcType
4237                         Pos
4238                         SrcAOID   AOID
4239                         Loop      bool
4240                         Fade      float32
4241                         Pitch     float32
4242                         Ephemeral bool
4243                 }))(obj)).SrcAOID).deserialize(r)
4244         }); err != nil {
4245                 if err == io.EOF {
4246                         chk(io.EOF)
4247                 }
4248                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
4249         }
4250         {
4251                 p := &(*(*(struct {
4252                         ID      SoundID
4253                         Name    string
4254                         Gain    float32
4255                         SrcType SoundSrcType
4256                         Pos
4257                         SrcAOID   AOID
4258                         Loop      bool
4259                         Fade      float32
4260                         Pitch     float32
4261                         Ephemeral bool
4262                 }))(obj)).Loop
4263                 switch n := read8(r); n {
4264                 case 0:
4265                         *p = false
4266                 case 1:
4267                         *p = true
4268                 default:
4269                         chk(fmt.Errorf("invalid bool: %d", n))
4270                 }
4271
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)).Fade
4286                 *p = math.Float32frombits(read32(r))
4287         }
4288         {
4289                 p := &(*(*(struct {
4290                         ID      SoundID
4291                         Name    string
4292                         Gain    float32
4293                         SrcType SoundSrcType
4294                         Pos
4295                         SrcAOID   AOID
4296                         Loop      bool
4297                         Fade      float32
4298                         Pitch     float32
4299                         Ephemeral bool
4300                 }))(obj)).Pitch
4301                 *p = math.Float32frombits(read32(r))
4302         }
4303         {
4304                 p := &(*(*(struct {
4305                         ID      SoundID
4306                         Name    string
4307                         Gain    float32
4308                         SrcType SoundSrcType
4309                         Pos
4310                         SrcAOID   AOID
4311                         Loop      bool
4312                         Fade      float32
4313                         Pitch     float32
4314                         Ephemeral bool
4315                 }))(obj)).Ephemeral
4316                 switch n := read8(r); n {
4317                 case 0:
4318                         *p = false
4319                 case 1:
4320                         *p = true
4321                 default:
4322                         chk(fmt.Errorf("invalid bool: %d", n))
4323                 }
4324
4325         }
4326 }
4327
4328 func (obj *ToCltStopSound) serialize(w io.Writer) {
4329         if err := pcall(func() {
4330                 ((*(*(struct {
4331                         ID SoundID
4332                 }))(obj)).ID).serialize(w)
4333         }); err != nil {
4334                 if err == io.EOF {
4335                         chk(io.EOF)
4336                 }
4337                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
4338         }
4339 }
4340
4341 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4342         if err := pcall(func() {
4343                 ((*(*(struct {
4344                         ID SoundID
4345                 }))(obj)).ID).deserialize(r)
4346         }); err != nil {
4347                 if err == io.EOF {
4348                         chk(io.EOF)
4349                 }
4350                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
4351         }
4352 }
4353
4354 func (obj *ToCltPrivs) serialize(w io.Writer) {
4355         if len(((*(*(struct {
4356                 Privs []string
4357         }))(obj)).Privs)) > math.MaxUint16 {
4358                 chk(ErrTooLong)
4359         }
4360         {
4361                 x := uint16(len(((*(*(struct {
4362                         Privs []string
4363                 }))(obj)).Privs)))
4364                 write16(w, uint16(x))
4365         }
4366         for local132 := range (*(*(struct {
4367                 Privs []string
4368         }))(obj)).Privs {
4369                 if len(([]byte(((*(*(struct {
4370                         Privs []string
4371                 }))(obj)).Privs)[local132]))) > math.MaxUint16 {
4372                         chk(ErrTooLong)
4373                 }
4374                 {
4375                         x := uint16(len(([]byte(((*(*(struct {
4376                                 Privs []string
4377                         }))(obj)).Privs)[local132]))))
4378                         write16(w, uint16(x))
4379                 }
4380                 {
4381                         _, err := w.Write(([]byte(((*(*(struct {
4382                                 Privs []string
4383                         }))(obj)).Privs)[local132]))[:])
4384                         chk(err)
4385                 }
4386         }
4387 }
4388
4389 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4390         var local133 uint16
4391         {
4392                 p := &local133
4393                 *p = read16(r)
4394         }
4395         ((*(*(struct {
4396                 Privs []string
4397         }))(obj)).Privs) = make([]string, local133)
4398         for local134 := range (*(*(struct {
4399                 Privs []string
4400         }))(obj)).Privs {
4401                 var local135 []uint8
4402                 var local136 uint16
4403                 {
4404                         p := &local136
4405                         *p = read16(r)
4406                 }
4407                 (local135) = make([]uint8, local136)
4408                 {
4409                         _, err := io.ReadFull(r, (local135)[:])
4410                         chk(err)
4411                 }
4412                 (((*(*(struct {
4413                         Privs []string
4414                 }))(obj)).Privs)[local134]) = string(local135)
4415         }
4416 }
4417
4418 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4419         if len(([]byte((*(*(struct {
4420                 //mt:len32
4421                 Formspec string
4422         }))(obj)).Formspec))) > math.MaxUint32 {
4423                 chk(ErrTooLong)
4424         }
4425         {
4426                 x := uint32(len(([]byte((*(*(struct {
4427                         //mt:len32
4428                         Formspec string
4429                 }))(obj)).Formspec))))
4430                 write32(w, uint32(x))
4431         }
4432         {
4433                 _, err := w.Write(([]byte((*(*(struct {
4434                         //mt:len32
4435                         Formspec string
4436                 }))(obj)).Formspec))[:])
4437                 chk(err)
4438         }
4439 }
4440
4441 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4442         var local137 []uint8
4443         var local138 uint32
4444         {
4445                 p := &local138
4446                 *p = read32(r)
4447         }
4448         (local137) = make([]uint8, local138)
4449         {
4450                 _, err := io.ReadFull(r, (local137)[:])
4451                 chk(err)
4452         }
4453         ((*(*(struct {
4454                 //mt:len32
4455                 Formspec string
4456         }))(obj)).Formspec) = string(local137)
4457 }
4458
4459 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4460         if len(([]byte((*(*(struct {
4461                 Name string
4462                 Keep bool
4463                 Len  uint16 // deprecated
4464
4465                 //mt:raw
4466                 Inv string
4467         }))(obj)).Name))) > math.MaxUint16 {
4468                 chk(ErrTooLong)
4469         }
4470         {
4471                 x := uint16(len(([]byte((*(*(struct {
4472                         Name string
4473                         Keep bool
4474                         Len  uint16 // deprecated
4475
4476                         //mt:raw
4477                         Inv string
4478                 }))(obj)).Name))))
4479                 write16(w, uint16(x))
4480         }
4481         {
4482                 _, err := w.Write(([]byte((*(*(struct {
4483                         Name string
4484                         Keep bool
4485                         Len  uint16 // deprecated
4486
4487                         //mt:raw
4488                         Inv string
4489                 }))(obj)).Name))[:])
4490                 chk(err)
4491         }
4492         {
4493                 x := (*(*(struct {
4494                         Name string
4495                         Keep bool
4496                         Len  uint16 // deprecated
4497
4498                         //mt:raw
4499                         Inv string
4500                 }))(obj)).Keep
4501                 if x {
4502                         write8(w, 1)
4503                 } else {
4504                         write8(w, 0)
4505                 }
4506
4507         }
4508         {
4509                 x := (*(*(struct {
4510                         Name string
4511                         Keep bool
4512                         Len  uint16 // deprecated
4513
4514                         //mt:raw
4515                         Inv string
4516                 }))(obj)).Len
4517                 write16(w, uint16(x))
4518         }
4519         {
4520                 _, err := w.Write(([]byte((*(*(struct {
4521                         Name string
4522                         Keep bool
4523                         Len  uint16 // deprecated
4524
4525                         //mt:raw
4526                         Inv string
4527                 }))(obj)).Inv))[:])
4528                 chk(err)
4529         }
4530 }
4531
4532 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4533         var local139 []uint8
4534         var local140 uint16
4535         {
4536                 p := &local140
4537                 *p = read16(r)
4538         }
4539         (local139) = make([]uint8, local140)
4540         {
4541                 _, err := io.ReadFull(r, (local139)[:])
4542                 chk(err)
4543         }
4544         ((*(*(struct {
4545                 Name string
4546                 Keep bool
4547                 Len  uint16 // deprecated
4548
4549                 //mt:raw
4550                 Inv string
4551         }))(obj)).Name) = string(local139)
4552         {
4553                 p := &(*(*(struct {
4554                         Name string
4555                         Keep bool
4556                         Len  uint16 // deprecated
4557
4558                         //mt:raw
4559                         Inv string
4560                 }))(obj)).Keep
4561                 switch n := read8(r); n {
4562                 case 0:
4563                         *p = false
4564                 case 1:
4565                         *p = true
4566                 default:
4567                         chk(fmt.Errorf("invalid bool: %d", n))
4568                 }
4569
4570         }
4571         {
4572                 p := &(*(*(struct {
4573                         Name string
4574                         Keep bool
4575                         Len  uint16 // deprecated
4576
4577                         //mt:raw
4578                         Inv string
4579                 }))(obj)).Len
4580                 *p = read16(r)
4581         }
4582         var local141 []uint8
4583         {
4584                 var err error
4585                 (local141), err = io.ReadAll(r)
4586                 chk(err)
4587         }
4588         ((*(*(struct {
4589                 Name string
4590                 Keep bool
4591                 Len  uint16 // deprecated
4592
4593                 //mt:raw
4594                 Inv string
4595         }))(obj)).Inv) = string(local141)
4596 }
4597
4598 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4599         if len(([]byte((*(*(struct {
4600                 //mt:len32
4601                 Formspec string
4602
4603                 Formname string
4604         }))(obj)).Formspec))) > math.MaxUint32 {
4605                 chk(ErrTooLong)
4606         }
4607         {
4608                 x := uint32(len(([]byte((*(*(struct {
4609                         //mt:len32
4610                         Formspec string
4611
4612                         Formname string
4613                 }))(obj)).Formspec))))
4614                 write32(w, uint32(x))
4615         }
4616         {
4617                 _, err := w.Write(([]byte((*(*(struct {
4618                         //mt:len32
4619                         Formspec string
4620
4621                         Formname string
4622                 }))(obj)).Formspec))[:])
4623                 chk(err)
4624         }
4625         if len(([]byte((*(*(struct {
4626                 //mt:len32
4627                 Formspec string
4628
4629                 Formname string
4630         }))(obj)).Formname))) > math.MaxUint16 {
4631                 chk(ErrTooLong)
4632         }
4633         {
4634                 x := uint16(len(([]byte((*(*(struct {
4635                         //mt:len32
4636                         Formspec string
4637
4638                         Formname string
4639                 }))(obj)).Formname))))
4640                 write16(w, uint16(x))
4641         }
4642         {
4643                 _, err := w.Write(([]byte((*(*(struct {
4644                         //mt:len32
4645                         Formspec string
4646
4647                         Formname string
4648                 }))(obj)).Formname))[:])
4649                 chk(err)
4650         }
4651 }
4652
4653 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4654         var local142 []uint8
4655         var local143 uint32
4656         {
4657                 p := &local143
4658                 *p = read32(r)
4659         }
4660         (local142) = make([]uint8, local143)
4661         {
4662                 _, err := io.ReadFull(r, (local142)[:])
4663                 chk(err)
4664         }
4665         ((*(*(struct {
4666                 //mt:len32
4667                 Formspec string
4668
4669                 Formname string
4670         }))(obj)).Formspec) = string(local142)
4671         var local144 []uint8
4672         var local145 uint16
4673         {
4674                 p := &local145
4675                 *p = read16(r)
4676         }
4677         (local144) = make([]uint8, local145)
4678         {
4679                 _, err := io.ReadFull(r, (local144)[:])
4680                 chk(err)
4681         }
4682         ((*(*(struct {
4683                 //mt:len32
4684                 Formspec string
4685
4686                 Formname string
4687         }))(obj)).Formname) = string(local144)
4688 }
4689
4690 func (obj *ToCltMovement) serialize(w io.Writer) {
4691         {
4692                 x := (*(*(struct {
4693                         DefaultAccel, AirAccel, FastAccel,
4694                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4695                         Fluidity, Smoothing, Sink,
4696                         Gravity float32
4697                 }))(obj)).DefaultAccel
4698                 write32(w, math.Float32bits(x))
4699         }
4700         {
4701                 x := (*(*(struct {
4702                         DefaultAccel, AirAccel, FastAccel,
4703                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4704                         Fluidity, Smoothing, Sink,
4705                         Gravity float32
4706                 }))(obj)).AirAccel
4707                 write32(w, math.Float32bits(x))
4708         }
4709         {
4710                 x := (*(*(struct {
4711                         DefaultAccel, AirAccel, FastAccel,
4712                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4713                         Fluidity, Smoothing, Sink,
4714                         Gravity float32
4715                 }))(obj)).FastAccel
4716                 write32(w, math.Float32bits(x))
4717         }
4718         {
4719                 x := (*(*(struct {
4720                         DefaultAccel, AirAccel, FastAccel,
4721                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4722                         Fluidity, Smoothing, Sink,
4723                         Gravity float32
4724                 }))(obj)).WalkSpeed
4725                 write32(w, math.Float32bits(x))
4726         }
4727         {
4728                 x := (*(*(struct {
4729                         DefaultAccel, AirAccel, FastAccel,
4730                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4731                         Fluidity, Smoothing, Sink,
4732                         Gravity float32
4733                 }))(obj)).CrouchSpeed
4734                 write32(w, math.Float32bits(x))
4735         }
4736         {
4737                 x := (*(*(struct {
4738                         DefaultAccel, AirAccel, FastAccel,
4739                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4740                         Fluidity, Smoothing, Sink,
4741                         Gravity float32
4742                 }))(obj)).FastSpeed
4743                 write32(w, math.Float32bits(x))
4744         }
4745         {
4746                 x := (*(*(struct {
4747                         DefaultAccel, AirAccel, FastAccel,
4748                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4749                         Fluidity, Smoothing, Sink,
4750                         Gravity float32
4751                 }))(obj)).ClimbSpeed
4752                 write32(w, math.Float32bits(x))
4753         }
4754         {
4755                 x := (*(*(struct {
4756                         DefaultAccel, AirAccel, FastAccel,
4757                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4758                         Fluidity, Smoothing, Sink,
4759                         Gravity float32
4760                 }))(obj)).JumpSpeed
4761                 write32(w, math.Float32bits(x))
4762         }
4763         {
4764                 x := (*(*(struct {
4765                         DefaultAccel, AirAccel, FastAccel,
4766                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4767                         Fluidity, Smoothing, Sink,
4768                         Gravity float32
4769                 }))(obj)).Fluidity
4770                 write32(w, math.Float32bits(x))
4771         }
4772         {
4773                 x := (*(*(struct {
4774                         DefaultAccel, AirAccel, FastAccel,
4775                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4776                         Fluidity, Smoothing, Sink,
4777                         Gravity float32
4778                 }))(obj)).Smoothing
4779                 write32(w, math.Float32bits(x))
4780         }
4781         {
4782                 x := (*(*(struct {
4783                         DefaultAccel, AirAccel, FastAccel,
4784                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4785                         Fluidity, Smoothing, Sink,
4786                         Gravity float32
4787                 }))(obj)).Sink
4788                 write32(w, math.Float32bits(x))
4789         }
4790         {
4791                 x := (*(*(struct {
4792                         DefaultAccel, AirAccel, FastAccel,
4793                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4794                         Fluidity, Smoothing, Sink,
4795                         Gravity float32
4796                 }))(obj)).Gravity
4797                 write32(w, math.Float32bits(x))
4798         }
4799 }
4800
4801 func (obj *ToCltMovement) deserialize(r io.Reader) {
4802         {
4803                 p := &(*(*(struct {
4804                         DefaultAccel, AirAccel, FastAccel,
4805                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4806                         Fluidity, Smoothing, Sink,
4807                         Gravity float32
4808                 }))(obj)).DefaultAccel
4809                 *p = math.Float32frombits(read32(r))
4810         }
4811         {
4812                 p := &(*(*(struct {
4813                         DefaultAccel, AirAccel, FastAccel,
4814                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4815                         Fluidity, Smoothing, Sink,
4816                         Gravity float32
4817                 }))(obj)).AirAccel
4818                 *p = math.Float32frombits(read32(r))
4819         }
4820         {
4821                 p := &(*(*(struct {
4822                         DefaultAccel, AirAccel, FastAccel,
4823                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4824                         Fluidity, Smoothing, Sink,
4825                         Gravity float32
4826                 }))(obj)).FastAccel
4827                 *p = math.Float32frombits(read32(r))
4828         }
4829         {
4830                 p := &(*(*(struct {
4831                         DefaultAccel, AirAccel, FastAccel,
4832                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4833                         Fluidity, Smoothing, Sink,
4834                         Gravity float32
4835                 }))(obj)).WalkSpeed
4836                 *p = math.Float32frombits(read32(r))
4837         }
4838         {
4839                 p := &(*(*(struct {
4840                         DefaultAccel, AirAccel, FastAccel,
4841                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4842                         Fluidity, Smoothing, Sink,
4843                         Gravity float32
4844                 }))(obj)).CrouchSpeed
4845                 *p = math.Float32frombits(read32(r))
4846         }
4847         {
4848                 p := &(*(*(struct {
4849                         DefaultAccel, AirAccel, FastAccel,
4850                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4851                         Fluidity, Smoothing, Sink,
4852                         Gravity float32
4853                 }))(obj)).FastSpeed
4854                 *p = math.Float32frombits(read32(r))
4855         }
4856         {
4857                 p := &(*(*(struct {
4858                         DefaultAccel, AirAccel, FastAccel,
4859                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4860                         Fluidity, Smoothing, Sink,
4861                         Gravity float32
4862                 }))(obj)).ClimbSpeed
4863                 *p = math.Float32frombits(read32(r))
4864         }
4865         {
4866                 p := &(*(*(struct {
4867                         DefaultAccel, AirAccel, FastAccel,
4868                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4869                         Fluidity, Smoothing, Sink,
4870                         Gravity float32
4871                 }))(obj)).JumpSpeed
4872                 *p = math.Float32frombits(read32(r))
4873         }
4874         {
4875                 p := &(*(*(struct {
4876                         DefaultAccel, AirAccel, FastAccel,
4877                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4878                         Fluidity, Smoothing, Sink,
4879                         Gravity float32
4880                 }))(obj)).Fluidity
4881                 *p = math.Float32frombits(read32(r))
4882         }
4883         {
4884                 p := &(*(*(struct {
4885                         DefaultAccel, AirAccel, FastAccel,
4886                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4887                         Fluidity, Smoothing, Sink,
4888                         Gravity float32
4889                 }))(obj)).Smoothing
4890                 *p = math.Float32frombits(read32(r))
4891         }
4892         {
4893                 p := &(*(*(struct {
4894                         DefaultAccel, AirAccel, FastAccel,
4895                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4896                         Fluidity, Smoothing, Sink,
4897                         Gravity float32
4898                 }))(obj)).Sink
4899                 *p = math.Float32frombits(read32(r))
4900         }
4901         {
4902                 p := &(*(*(struct {
4903                         DefaultAccel, AirAccel, FastAccel,
4904                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4905                         Fluidity, Smoothing, Sink,
4906                         Gravity float32
4907                 }))(obj)).Gravity
4908                 *p = math.Float32frombits(read32(r))
4909         }
4910 }
4911
4912 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4913         for local146 := range (*(*(struct {
4914                 Pos, Vel, Acc  [3]float32
4915                 ExpirationTime float32 // in seconds.
4916                 Size           float32
4917                 Collide        bool
4918
4919                 //mt:len32
4920                 Texture
4921
4922                 Vertical    bool
4923                 CollisionRm bool
4924                 AnimParams  TileAnim
4925                 Glow        uint8
4926                 AOCollision bool
4927                 NodeParam0  Content
4928                 NodeParam2  uint8
4929                 NodeTile    uint8
4930         }))(obj)).Pos {
4931                 {
4932                         x := ((*(*(struct {
4933                                 Pos, Vel, Acc  [3]float32
4934                                 ExpirationTime float32 // in seconds.
4935                                 Size           float32
4936                                 Collide        bool
4937
4938                                 //mt:len32
4939                                 Texture
4940
4941                                 Vertical    bool
4942                                 CollisionRm bool
4943                                 AnimParams  TileAnim
4944                                 Glow        uint8
4945                                 AOCollision bool
4946                                 NodeParam0  Content
4947                                 NodeParam2  uint8
4948                                 NodeTile    uint8
4949                         }))(obj)).Pos)[local146]
4950                         write32(w, math.Float32bits(x))
4951                 }
4952         }
4953         for local147 := range (*(*(struct {
4954                 Pos, Vel, Acc  [3]float32
4955                 ExpirationTime float32 // in seconds.
4956                 Size           float32
4957                 Collide        bool
4958
4959                 //mt:len32
4960                 Texture
4961
4962                 Vertical    bool
4963                 CollisionRm bool
4964                 AnimParams  TileAnim
4965                 Glow        uint8
4966                 AOCollision bool
4967                 NodeParam0  Content
4968                 NodeParam2  uint8
4969                 NodeTile    uint8
4970         }))(obj)).Vel {
4971                 {
4972                         x := ((*(*(struct {
4973                                 Pos, Vel, Acc  [3]float32
4974                                 ExpirationTime float32 // in seconds.
4975                                 Size           float32
4976                                 Collide        bool
4977
4978                                 //mt:len32
4979                                 Texture
4980
4981                                 Vertical    bool
4982                                 CollisionRm bool
4983                                 AnimParams  TileAnim
4984                                 Glow        uint8
4985                                 AOCollision bool
4986                                 NodeParam0  Content
4987                                 NodeParam2  uint8
4988                                 NodeTile    uint8
4989                         }))(obj)).Vel)[local147]
4990                         write32(w, math.Float32bits(x))
4991                 }
4992         }
4993         for local148 := range (*(*(struct {
4994                 Pos, Vel, Acc  [3]float32
4995                 ExpirationTime float32 // in seconds.
4996                 Size           float32
4997                 Collide        bool
4998
4999                 //mt:len32
5000                 Texture
5001
5002                 Vertical    bool
5003                 CollisionRm bool
5004                 AnimParams  TileAnim
5005                 Glow        uint8
5006                 AOCollision bool
5007                 NodeParam0  Content
5008                 NodeParam2  uint8
5009                 NodeTile    uint8
5010         }))(obj)).Acc {
5011                 {
5012                         x := ((*(*(struct {
5013                                 Pos, Vel, Acc  [3]float32
5014                                 ExpirationTime float32 // in seconds.
5015                                 Size           float32
5016                                 Collide        bool
5017
5018                                 //mt:len32
5019                                 Texture
5020
5021                                 Vertical    bool
5022                                 CollisionRm bool
5023                                 AnimParams  TileAnim
5024                                 Glow        uint8
5025                                 AOCollision bool
5026                                 NodeParam0  Content
5027                                 NodeParam2  uint8
5028                                 NodeTile    uint8
5029                         }))(obj)).Acc)[local148]
5030                         write32(w, math.Float32bits(x))
5031                 }
5032         }
5033         {
5034                 x := (*(*(struct {
5035                         Pos, Vel, Acc  [3]float32
5036                         ExpirationTime float32 // in seconds.
5037                         Size           float32
5038                         Collide        bool
5039
5040                         //mt:len32
5041                         Texture
5042
5043                         Vertical    bool
5044                         CollisionRm bool
5045                         AnimParams  TileAnim
5046                         Glow        uint8
5047                         AOCollision bool
5048                         NodeParam0  Content
5049                         NodeParam2  uint8
5050                         NodeTile    uint8
5051                 }))(obj)).ExpirationTime
5052                 write32(w, math.Float32bits(x))
5053         }
5054         {
5055                 x := (*(*(struct {
5056                         Pos, Vel, Acc  [3]float32
5057                         ExpirationTime float32 // in seconds.
5058                         Size           float32
5059                         Collide        bool
5060
5061                         //mt:len32
5062                         Texture
5063
5064                         Vertical    bool
5065                         CollisionRm bool
5066                         AnimParams  TileAnim
5067                         Glow        uint8
5068                         AOCollision bool
5069                         NodeParam0  Content
5070                         NodeParam2  uint8
5071                         NodeTile    uint8
5072                 }))(obj)).Size
5073                 write32(w, math.Float32bits(x))
5074         }
5075         {
5076                 x := (*(*(struct {
5077                         Pos, Vel, Acc  [3]float32
5078                         ExpirationTime float32 // in seconds.
5079                         Size           float32
5080                         Collide        bool
5081
5082                         //mt:len32
5083                         Texture
5084
5085                         Vertical    bool
5086                         CollisionRm bool
5087                         AnimParams  TileAnim
5088                         Glow        uint8
5089                         AOCollision bool
5090                         NodeParam0  Content
5091                         NodeParam2  uint8
5092                         NodeTile    uint8
5093                 }))(obj)).Collide
5094                 if x {
5095                         write8(w, 1)
5096                 } else {
5097                         write8(w, 0)
5098                 }
5099
5100         }
5101         if len(([]byte(*(*string)(&((*(*(struct {
5102                 Pos, Vel, Acc  [3]float32
5103                 ExpirationTime float32 // in seconds.
5104                 Size           float32
5105                 Collide        bool
5106
5107                 //mt:len32
5108                 Texture
5109
5110                 Vertical    bool
5111                 CollisionRm bool
5112                 AnimParams  TileAnim
5113                 Glow        uint8
5114                 AOCollision bool
5115                 NodeParam0  Content
5116                 NodeParam2  uint8
5117                 NodeTile    uint8
5118         }))(obj)).Texture))))) > math.MaxUint32 {
5119                 chk(ErrTooLong)
5120         }
5121         {
5122                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5123                         Pos, Vel, Acc  [3]float32
5124                         ExpirationTime float32 // in seconds.
5125                         Size           float32
5126                         Collide        bool
5127
5128                         //mt:len32
5129                         Texture
5130
5131                         Vertical    bool
5132                         CollisionRm bool
5133                         AnimParams  TileAnim
5134                         Glow        uint8
5135                         AOCollision bool
5136                         NodeParam0  Content
5137                         NodeParam2  uint8
5138                         NodeTile    uint8
5139                 }))(obj)).Texture))))))
5140                 write32(w, uint32(x))
5141         }
5142         {
5143                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5144                         Pos, Vel, Acc  [3]float32
5145                         ExpirationTime float32 // in seconds.
5146                         Size           float32
5147                         Collide        bool
5148
5149                         //mt:len32
5150                         Texture
5151
5152                         Vertical    bool
5153                         CollisionRm bool
5154                         AnimParams  TileAnim
5155                         Glow        uint8
5156                         AOCollision bool
5157                         NodeParam0  Content
5158                         NodeParam2  uint8
5159                         NodeTile    uint8
5160                 }))(obj)).Texture))))[:])
5161                 chk(err)
5162         }
5163         {
5164                 x := (*(*(struct {
5165                         Pos, Vel, Acc  [3]float32
5166                         ExpirationTime float32 // in seconds.
5167                         Size           float32
5168                         Collide        bool
5169
5170                         //mt:len32
5171                         Texture
5172
5173                         Vertical    bool
5174                         CollisionRm bool
5175                         AnimParams  TileAnim
5176                         Glow        uint8
5177                         AOCollision bool
5178                         NodeParam0  Content
5179                         NodeParam2  uint8
5180                         NodeTile    uint8
5181                 }))(obj)).Vertical
5182                 if x {
5183                         write8(w, 1)
5184                 } else {
5185                         write8(w, 0)
5186                 }
5187
5188         }
5189         {
5190                 x := (*(*(struct {
5191                         Pos, Vel, Acc  [3]float32
5192                         ExpirationTime float32 // in seconds.
5193                         Size           float32
5194                         Collide        bool
5195
5196                         //mt:len32
5197                         Texture
5198
5199                         Vertical    bool
5200                         CollisionRm bool
5201                         AnimParams  TileAnim
5202                         Glow        uint8
5203                         AOCollision bool
5204                         NodeParam0  Content
5205                         NodeParam2  uint8
5206                         NodeTile    uint8
5207                 }))(obj)).CollisionRm
5208                 if x {
5209                         write8(w, 1)
5210                 } else {
5211                         write8(w, 0)
5212                 }
5213
5214         }
5215         if err := pcall(func() {
5216                 ((*(*(struct {
5217                         Pos, Vel, Acc  [3]float32
5218                         ExpirationTime float32 // in seconds.
5219                         Size           float32
5220                         Collide        bool
5221
5222                         //mt:len32
5223                         Texture
5224
5225                         Vertical    bool
5226                         CollisionRm bool
5227                         AnimParams  TileAnim
5228                         Glow        uint8
5229                         AOCollision bool
5230                         NodeParam0  Content
5231                         NodeParam2  uint8
5232                         NodeTile    uint8
5233                 }))(obj)).AnimParams).serialize(w)
5234         }); err != nil {
5235                 if err == io.EOF {
5236                         chk(io.EOF)
5237                 }
5238                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
5239         }
5240         {
5241                 x := (*(*(struct {
5242                         Pos, Vel, Acc  [3]float32
5243                         ExpirationTime float32 // in seconds.
5244                         Size           float32
5245                         Collide        bool
5246
5247                         //mt:len32
5248                         Texture
5249
5250                         Vertical    bool
5251                         CollisionRm bool
5252                         AnimParams  TileAnim
5253                         Glow        uint8
5254                         AOCollision bool
5255                         NodeParam0  Content
5256                         NodeParam2  uint8
5257                         NodeTile    uint8
5258                 }))(obj)).Glow
5259                 write8(w, uint8(x))
5260         }
5261         {
5262                 x := (*(*(struct {
5263                         Pos, Vel, Acc  [3]float32
5264                         ExpirationTime float32 // in seconds.
5265                         Size           float32
5266                         Collide        bool
5267
5268                         //mt:len32
5269                         Texture
5270
5271                         Vertical    bool
5272                         CollisionRm bool
5273                         AnimParams  TileAnim
5274                         Glow        uint8
5275                         AOCollision bool
5276                         NodeParam0  Content
5277                         NodeParam2  uint8
5278                         NodeTile    uint8
5279                 }))(obj)).AOCollision
5280                 if x {
5281                         write8(w, 1)
5282                 } else {
5283                         write8(w, 0)
5284                 }
5285
5286         }
5287         if err := pcall(func() {
5288                 ((*(*(struct {
5289                         Pos, Vel, Acc  [3]float32
5290                         ExpirationTime float32 // in seconds.
5291                         Size           float32
5292                         Collide        bool
5293
5294                         //mt:len32
5295                         Texture
5296
5297                         Vertical    bool
5298                         CollisionRm bool
5299                         AnimParams  TileAnim
5300                         Glow        uint8
5301                         AOCollision bool
5302                         NodeParam0  Content
5303                         NodeParam2  uint8
5304                         NodeTile    uint8
5305                 }))(obj)).NodeParam0).serialize(w)
5306         }); err != nil {
5307                 if err == io.EOF {
5308                         chk(io.EOF)
5309                 }
5310                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
5311         }
5312         {
5313                 x := (*(*(struct {
5314                         Pos, Vel, Acc  [3]float32
5315                         ExpirationTime float32 // in seconds.
5316                         Size           float32
5317                         Collide        bool
5318
5319                         //mt:len32
5320                         Texture
5321
5322                         Vertical    bool
5323                         CollisionRm bool
5324                         AnimParams  TileAnim
5325                         Glow        uint8
5326                         AOCollision bool
5327                         NodeParam0  Content
5328                         NodeParam2  uint8
5329                         NodeTile    uint8
5330                 }))(obj)).NodeParam2
5331                 write8(w, uint8(x))
5332         }
5333         {
5334                 x := (*(*(struct {
5335                         Pos, Vel, Acc  [3]float32
5336                         ExpirationTime float32 // in seconds.
5337                         Size           float32
5338                         Collide        bool
5339
5340                         //mt:len32
5341                         Texture
5342
5343                         Vertical    bool
5344                         CollisionRm bool
5345                         AnimParams  TileAnim
5346                         Glow        uint8
5347                         AOCollision bool
5348                         NodeParam0  Content
5349                         NodeParam2  uint8
5350                         NodeTile    uint8
5351                 }))(obj)).NodeTile
5352                 write8(w, uint8(x))
5353         }
5354 }
5355
5356 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5357         for local149 := range (*(*(struct {
5358                 Pos, Vel, Acc  [3]float32
5359                 ExpirationTime float32 // in seconds.
5360                 Size           float32
5361                 Collide        bool
5362
5363                 //mt:len32
5364                 Texture
5365
5366                 Vertical    bool
5367                 CollisionRm bool
5368                 AnimParams  TileAnim
5369                 Glow        uint8
5370                 AOCollision bool
5371                 NodeParam0  Content
5372                 NodeParam2  uint8
5373                 NodeTile    uint8
5374         }))(obj)).Pos {
5375                 {
5376                         p := &((*(*(struct {
5377                                 Pos, Vel, Acc  [3]float32
5378                                 ExpirationTime float32 // in seconds.
5379                                 Size           float32
5380                                 Collide        bool
5381
5382                                 //mt:len32
5383                                 Texture
5384
5385                                 Vertical    bool
5386                                 CollisionRm bool
5387                                 AnimParams  TileAnim
5388                                 Glow        uint8
5389                                 AOCollision bool
5390                                 NodeParam0  Content
5391                                 NodeParam2  uint8
5392                                 NodeTile    uint8
5393                         }))(obj)).Pos)[local149]
5394                         *p = math.Float32frombits(read32(r))
5395                 }
5396         }
5397         for local150 := range (*(*(struct {
5398                 Pos, Vel, Acc  [3]float32
5399                 ExpirationTime float32 // in seconds.
5400                 Size           float32
5401                 Collide        bool
5402
5403                 //mt:len32
5404                 Texture
5405
5406                 Vertical    bool
5407                 CollisionRm bool
5408                 AnimParams  TileAnim
5409                 Glow        uint8
5410                 AOCollision bool
5411                 NodeParam0  Content
5412                 NodeParam2  uint8
5413                 NodeTile    uint8
5414         }))(obj)).Vel {
5415                 {
5416                         p := &((*(*(struct {
5417                                 Pos, Vel, Acc  [3]float32
5418                                 ExpirationTime float32 // in seconds.
5419                                 Size           float32
5420                                 Collide        bool
5421
5422                                 //mt:len32
5423                                 Texture
5424
5425                                 Vertical    bool
5426                                 CollisionRm bool
5427                                 AnimParams  TileAnim
5428                                 Glow        uint8
5429                                 AOCollision bool
5430                                 NodeParam0  Content
5431                                 NodeParam2  uint8
5432                                 NodeTile    uint8
5433                         }))(obj)).Vel)[local150]
5434                         *p = math.Float32frombits(read32(r))
5435                 }
5436         }
5437         for local151 := range (*(*(struct {
5438                 Pos, Vel, Acc  [3]float32
5439                 ExpirationTime float32 // in seconds.
5440                 Size           float32
5441                 Collide        bool
5442
5443                 //mt:len32
5444                 Texture
5445
5446                 Vertical    bool
5447                 CollisionRm bool
5448                 AnimParams  TileAnim
5449                 Glow        uint8
5450                 AOCollision bool
5451                 NodeParam0  Content
5452                 NodeParam2  uint8
5453                 NodeTile    uint8
5454         }))(obj)).Acc {
5455                 {
5456                         p := &((*(*(struct {
5457                                 Pos, Vel, Acc  [3]float32
5458                                 ExpirationTime float32 // in seconds.
5459                                 Size           float32
5460                                 Collide        bool
5461
5462                                 //mt:len32
5463                                 Texture
5464
5465                                 Vertical    bool
5466                                 CollisionRm bool
5467                                 AnimParams  TileAnim
5468                                 Glow        uint8
5469                                 AOCollision bool
5470                                 NodeParam0  Content
5471                                 NodeParam2  uint8
5472                                 NodeTile    uint8
5473                         }))(obj)).Acc)[local151]
5474                         *p = math.Float32frombits(read32(r))
5475                 }
5476         }
5477         {
5478                 p := &(*(*(struct {
5479                         Pos, Vel, Acc  [3]float32
5480                         ExpirationTime float32 // in seconds.
5481                         Size           float32
5482                         Collide        bool
5483
5484                         //mt:len32
5485                         Texture
5486
5487                         Vertical    bool
5488                         CollisionRm bool
5489                         AnimParams  TileAnim
5490                         Glow        uint8
5491                         AOCollision bool
5492                         NodeParam0  Content
5493                         NodeParam2  uint8
5494                         NodeTile    uint8
5495                 }))(obj)).ExpirationTime
5496                 *p = math.Float32frombits(read32(r))
5497         }
5498         {
5499                 p := &(*(*(struct {
5500                         Pos, Vel, Acc  [3]float32
5501                         ExpirationTime float32 // in seconds.
5502                         Size           float32
5503                         Collide        bool
5504
5505                         //mt:len32
5506                         Texture
5507
5508                         Vertical    bool
5509                         CollisionRm bool
5510                         AnimParams  TileAnim
5511                         Glow        uint8
5512                         AOCollision bool
5513                         NodeParam0  Content
5514                         NodeParam2  uint8
5515                         NodeTile    uint8
5516                 }))(obj)).Size
5517                 *p = math.Float32frombits(read32(r))
5518         }
5519         {
5520                 p := &(*(*(struct {
5521                         Pos, Vel, Acc  [3]float32
5522                         ExpirationTime float32 // in seconds.
5523                         Size           float32
5524                         Collide        bool
5525
5526                         //mt:len32
5527                         Texture
5528
5529                         Vertical    bool
5530                         CollisionRm bool
5531                         AnimParams  TileAnim
5532                         Glow        uint8
5533                         AOCollision bool
5534                         NodeParam0  Content
5535                         NodeParam2  uint8
5536                         NodeTile    uint8
5537                 }))(obj)).Collide
5538                 switch n := read8(r); n {
5539                 case 0:
5540                         *p = false
5541                 case 1:
5542                         *p = true
5543                 default:
5544                         chk(fmt.Errorf("invalid bool: %d", n))
5545                 }
5546
5547         }
5548         var local152 []uint8
5549         var local153 uint32
5550         {
5551                 p := &local153
5552                 *p = read32(r)
5553         }
5554         (local152) = make([]uint8, local153)
5555         {
5556                 _, err := io.ReadFull(r, (local152)[:])
5557                 chk(err)
5558         }
5559         (*(*string)(&((*(*(struct {
5560                 Pos, Vel, Acc  [3]float32
5561                 ExpirationTime float32 // in seconds.
5562                 Size           float32
5563                 Collide        bool
5564
5565                 //mt:len32
5566                 Texture
5567
5568                 Vertical    bool
5569                 CollisionRm bool
5570                 AnimParams  TileAnim
5571                 Glow        uint8
5572                 AOCollision bool
5573                 NodeParam0  Content
5574                 NodeParam2  uint8
5575                 NodeTile    uint8
5576         }))(obj)).Texture))) = string(local152)
5577         {
5578                 p := &(*(*(struct {
5579                         Pos, Vel, Acc  [3]float32
5580                         ExpirationTime float32 // in seconds.
5581                         Size           float32
5582                         Collide        bool
5583
5584                         //mt:len32
5585                         Texture
5586
5587                         Vertical    bool
5588                         CollisionRm bool
5589                         AnimParams  TileAnim
5590                         Glow        uint8
5591                         AOCollision bool
5592                         NodeParam0  Content
5593                         NodeParam2  uint8
5594                         NodeTile    uint8
5595                 }))(obj)).Vertical
5596                 switch n := read8(r); n {
5597                 case 0:
5598                         *p = false
5599                 case 1:
5600                         *p = true
5601                 default:
5602                         chk(fmt.Errorf("invalid bool: %d", n))
5603                 }
5604
5605         }
5606         {
5607                 p := &(*(*(struct {
5608                         Pos, Vel, Acc  [3]float32
5609                         ExpirationTime float32 // in seconds.
5610                         Size           float32
5611                         Collide        bool
5612
5613                         //mt:len32
5614                         Texture
5615
5616                         Vertical    bool
5617                         CollisionRm bool
5618                         AnimParams  TileAnim
5619                         Glow        uint8
5620                         AOCollision bool
5621                         NodeParam0  Content
5622                         NodeParam2  uint8
5623                         NodeTile    uint8
5624                 }))(obj)).CollisionRm
5625                 switch n := read8(r); n {
5626                 case 0:
5627                         *p = false
5628                 case 1:
5629                         *p = true
5630                 default:
5631                         chk(fmt.Errorf("invalid bool: %d", n))
5632                 }
5633
5634         }
5635         if err := pcall(func() {
5636                 ((*(*(struct {
5637                         Pos, Vel, Acc  [3]float32
5638                         ExpirationTime float32 // in seconds.
5639                         Size           float32
5640                         Collide        bool
5641
5642                         //mt:len32
5643                         Texture
5644
5645                         Vertical    bool
5646                         CollisionRm bool
5647                         AnimParams  TileAnim
5648                         Glow        uint8
5649                         AOCollision bool
5650                         NodeParam0  Content
5651                         NodeParam2  uint8
5652                         NodeTile    uint8
5653                 }))(obj)).AnimParams).deserialize(r)
5654         }); err != nil {
5655                 if err == io.EOF {
5656                         chk(io.EOF)
5657                 }
5658                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
5659         }
5660         {
5661                 p := &(*(*(struct {
5662                         Pos, Vel, Acc  [3]float32
5663                         ExpirationTime float32 // in seconds.
5664                         Size           float32
5665                         Collide        bool
5666
5667                         //mt:len32
5668                         Texture
5669
5670                         Vertical    bool
5671                         CollisionRm bool
5672                         AnimParams  TileAnim
5673                         Glow        uint8
5674                         AOCollision bool
5675                         NodeParam0  Content
5676                         NodeParam2  uint8
5677                         NodeTile    uint8
5678                 }))(obj)).Glow
5679                 *p = read8(r)
5680         }
5681         {
5682                 p := &(*(*(struct {
5683                         Pos, Vel, Acc  [3]float32
5684                         ExpirationTime float32 // in seconds.
5685                         Size           float32
5686                         Collide        bool
5687
5688                         //mt:len32
5689                         Texture
5690
5691                         Vertical    bool
5692                         CollisionRm bool
5693                         AnimParams  TileAnim
5694                         Glow        uint8
5695                         AOCollision bool
5696                         NodeParam0  Content
5697                         NodeParam2  uint8
5698                         NodeTile    uint8
5699                 }))(obj)).AOCollision
5700                 switch n := read8(r); n {
5701                 case 0:
5702                         *p = false
5703                 case 1:
5704                         *p = true
5705                 default:
5706                         chk(fmt.Errorf("invalid bool: %d", n))
5707                 }
5708
5709         }
5710         if err := pcall(func() {
5711                 ((*(*(struct {
5712                         Pos, Vel, Acc  [3]float32
5713                         ExpirationTime float32 // in seconds.
5714                         Size           float32
5715                         Collide        bool
5716
5717                         //mt:len32
5718                         Texture
5719
5720                         Vertical    bool
5721                         CollisionRm bool
5722                         AnimParams  TileAnim
5723                         Glow        uint8
5724                         AOCollision bool
5725                         NodeParam0  Content
5726                         NodeParam2  uint8
5727                         NodeTile    uint8
5728                 }))(obj)).NodeParam0).deserialize(r)
5729         }); err != nil {
5730                 if err == io.EOF {
5731                         chk(io.EOF)
5732                 }
5733                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
5734         }
5735         {
5736                 p := &(*(*(struct {
5737                         Pos, Vel, Acc  [3]float32
5738                         ExpirationTime float32 // in seconds.
5739                         Size           float32
5740                         Collide        bool
5741
5742                         //mt:len32
5743                         Texture
5744
5745                         Vertical    bool
5746                         CollisionRm bool
5747                         AnimParams  TileAnim
5748                         Glow        uint8
5749                         AOCollision bool
5750                         NodeParam0  Content
5751                         NodeParam2  uint8
5752                         NodeTile    uint8
5753                 }))(obj)).NodeParam2
5754                 *p = read8(r)
5755         }
5756         {
5757                 p := &(*(*(struct {
5758                         Pos, Vel, Acc  [3]float32
5759                         ExpirationTime float32 // in seconds.
5760                         Size           float32
5761                         Collide        bool
5762
5763                         //mt:len32
5764                         Texture
5765
5766                         Vertical    bool
5767                         CollisionRm bool
5768                         AnimParams  TileAnim
5769                         Glow        uint8
5770                         AOCollision bool
5771                         NodeParam0  Content
5772                         NodeParam2  uint8
5773                         NodeTile    uint8
5774                 }))(obj)).NodeTile
5775                 *p = read8(r)
5776         }
5777 }
5778
5779 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5780         {
5781                 x := (*(*(struct {
5782                         Amount         uint16
5783                         Duration       float32
5784                         Pos, Vel, Acc  [2][3]float32
5785                         ExpirationTime [2]float32 // in seconds.
5786                         Size           [2]float32
5787                         Collide        bool
5788
5789                         //mt:len32
5790                         Texture
5791
5792                         ID           ParticleSpawnerID
5793                         Vertical     bool
5794                         CollisionRm  bool
5795                         AttachedAOID AOID
5796                         AnimParams   TileAnim
5797                         Glow         uint8
5798                         AOCollision  bool
5799                         NodeParam0   Content
5800                         NodeParam2   uint8
5801                         NodeTile     uint8
5802                 }))(obj)).Amount
5803                 write16(w, uint16(x))
5804         }
5805         {
5806                 x := (*(*(struct {
5807                         Amount         uint16
5808                         Duration       float32
5809                         Pos, Vel, Acc  [2][3]float32
5810                         ExpirationTime [2]float32 // in seconds.
5811                         Size           [2]float32
5812                         Collide        bool
5813
5814                         //mt:len32
5815                         Texture
5816
5817                         ID           ParticleSpawnerID
5818                         Vertical     bool
5819                         CollisionRm  bool
5820                         AttachedAOID AOID
5821                         AnimParams   TileAnim
5822                         Glow         uint8
5823                         AOCollision  bool
5824                         NodeParam0   Content
5825                         NodeParam2   uint8
5826                         NodeTile     uint8
5827                 }))(obj)).Duration
5828                 write32(w, math.Float32bits(x))
5829         }
5830         for local154 := range (*(*(struct {
5831                 Amount         uint16
5832                 Duration       float32
5833                 Pos, Vel, Acc  [2][3]float32
5834                 ExpirationTime [2]float32 // in seconds.
5835                 Size           [2]float32
5836                 Collide        bool
5837
5838                 //mt:len32
5839                 Texture
5840
5841                 ID           ParticleSpawnerID
5842                 Vertical     bool
5843                 CollisionRm  bool
5844                 AttachedAOID AOID
5845                 AnimParams   TileAnim
5846                 Glow         uint8
5847                 AOCollision  bool
5848                 NodeParam0   Content
5849                 NodeParam2   uint8
5850                 NodeTile     uint8
5851         }))(obj)).Pos {
5852                 for local155 := range ((*(*(struct {
5853                         Amount         uint16
5854                         Duration       float32
5855                         Pos, Vel, Acc  [2][3]float32
5856                         ExpirationTime [2]float32 // in seconds.
5857                         Size           [2]float32
5858                         Collide        bool
5859
5860                         //mt:len32
5861                         Texture
5862
5863                         ID           ParticleSpawnerID
5864                         Vertical     bool
5865                         CollisionRm  bool
5866                         AttachedAOID AOID
5867                         AnimParams   TileAnim
5868                         Glow         uint8
5869                         AOCollision  bool
5870                         NodeParam0   Content
5871                         NodeParam2   uint8
5872                         NodeTile     uint8
5873                 }))(obj)).Pos)[local154] {
5874                         {
5875                                 x := (((*(*(struct {
5876                                         Amount         uint16
5877                                         Duration       float32
5878                                         Pos, Vel, Acc  [2][3]float32
5879                                         ExpirationTime [2]float32 // in seconds.
5880                                         Size           [2]float32
5881                                         Collide        bool
5882
5883                                         //mt:len32
5884                                         Texture
5885
5886                                         ID           ParticleSpawnerID
5887                                         Vertical     bool
5888                                         CollisionRm  bool
5889                                         AttachedAOID AOID
5890                                         AnimParams   TileAnim
5891                                         Glow         uint8
5892                                         AOCollision  bool
5893                                         NodeParam0   Content
5894                                         NodeParam2   uint8
5895                                         NodeTile     uint8
5896                                 }))(obj)).Pos)[local154])[local155]
5897                                 write32(w, math.Float32bits(x))
5898                         }
5899                 }
5900         }
5901         for local156 := range (*(*(struct {
5902                 Amount         uint16
5903                 Duration       float32
5904                 Pos, Vel, Acc  [2][3]float32
5905                 ExpirationTime [2]float32 // in seconds.
5906                 Size           [2]float32
5907                 Collide        bool
5908
5909                 //mt:len32
5910                 Texture
5911
5912                 ID           ParticleSpawnerID
5913                 Vertical     bool
5914                 CollisionRm  bool
5915                 AttachedAOID AOID
5916                 AnimParams   TileAnim
5917                 Glow         uint8
5918                 AOCollision  bool
5919                 NodeParam0   Content
5920                 NodeParam2   uint8
5921                 NodeTile     uint8
5922         }))(obj)).Vel {
5923                 for local157 := range ((*(*(struct {
5924                         Amount         uint16
5925                         Duration       float32
5926                         Pos, Vel, Acc  [2][3]float32
5927                         ExpirationTime [2]float32 // in seconds.
5928                         Size           [2]float32
5929                         Collide        bool
5930
5931                         //mt:len32
5932                         Texture
5933
5934                         ID           ParticleSpawnerID
5935                         Vertical     bool
5936                         CollisionRm  bool
5937                         AttachedAOID AOID
5938                         AnimParams   TileAnim
5939                         Glow         uint8
5940                         AOCollision  bool
5941                         NodeParam0   Content
5942                         NodeParam2   uint8
5943                         NodeTile     uint8
5944                 }))(obj)).Vel)[local156] {
5945                         {
5946                                 x := (((*(*(struct {
5947                                         Amount         uint16
5948                                         Duration       float32
5949                                         Pos, Vel, Acc  [2][3]float32
5950                                         ExpirationTime [2]float32 // in seconds.
5951                                         Size           [2]float32
5952                                         Collide        bool
5953
5954                                         //mt:len32
5955                                         Texture
5956
5957                                         ID           ParticleSpawnerID
5958                                         Vertical     bool
5959                                         CollisionRm  bool
5960                                         AttachedAOID AOID
5961                                         AnimParams   TileAnim
5962                                         Glow         uint8
5963                                         AOCollision  bool
5964                                         NodeParam0   Content
5965                                         NodeParam2   uint8
5966                                         NodeTile     uint8
5967                                 }))(obj)).Vel)[local156])[local157]
5968                                 write32(w, math.Float32bits(x))
5969                         }
5970                 }
5971         }
5972         for local158 := range (*(*(struct {
5973                 Amount         uint16
5974                 Duration       float32
5975                 Pos, Vel, Acc  [2][3]float32
5976                 ExpirationTime [2]float32 // in seconds.
5977                 Size           [2]float32
5978                 Collide        bool
5979
5980                 //mt:len32
5981                 Texture
5982
5983                 ID           ParticleSpawnerID
5984                 Vertical     bool
5985                 CollisionRm  bool
5986                 AttachedAOID AOID
5987                 AnimParams   TileAnim
5988                 Glow         uint8
5989                 AOCollision  bool
5990                 NodeParam0   Content
5991                 NodeParam2   uint8
5992                 NodeTile     uint8
5993         }))(obj)).Acc {
5994                 for local159 := range ((*(*(struct {
5995                         Amount         uint16
5996                         Duration       float32
5997                         Pos, Vel, Acc  [2][3]float32
5998                         ExpirationTime [2]float32 // in seconds.
5999                         Size           [2]float32
6000                         Collide        bool
6001
6002                         //mt:len32
6003                         Texture
6004
6005                         ID           ParticleSpawnerID
6006                         Vertical     bool
6007                         CollisionRm  bool
6008                         AttachedAOID AOID
6009                         AnimParams   TileAnim
6010                         Glow         uint8
6011                         AOCollision  bool
6012                         NodeParam0   Content
6013                         NodeParam2   uint8
6014                         NodeTile     uint8
6015                 }))(obj)).Acc)[local158] {
6016                         {
6017                                 x := (((*(*(struct {
6018                                         Amount         uint16
6019                                         Duration       float32
6020                                         Pos, Vel, Acc  [2][3]float32
6021                                         ExpirationTime [2]float32 // in seconds.
6022                                         Size           [2]float32
6023                                         Collide        bool
6024
6025                                         //mt:len32
6026                                         Texture
6027
6028                                         ID           ParticleSpawnerID
6029                                         Vertical     bool
6030                                         CollisionRm  bool
6031                                         AttachedAOID AOID
6032                                         AnimParams   TileAnim
6033                                         Glow         uint8
6034                                         AOCollision  bool
6035                                         NodeParam0   Content
6036                                         NodeParam2   uint8
6037                                         NodeTile     uint8
6038                                 }))(obj)).Acc)[local158])[local159]
6039                                 write32(w, math.Float32bits(x))
6040                         }
6041                 }
6042         }
6043         for local160 := range (*(*(struct {
6044                 Amount         uint16
6045                 Duration       float32
6046                 Pos, Vel, Acc  [2][3]float32
6047                 ExpirationTime [2]float32 // in seconds.
6048                 Size           [2]float32
6049                 Collide        bool
6050
6051                 //mt:len32
6052                 Texture
6053
6054                 ID           ParticleSpawnerID
6055                 Vertical     bool
6056                 CollisionRm  bool
6057                 AttachedAOID AOID
6058                 AnimParams   TileAnim
6059                 Glow         uint8
6060                 AOCollision  bool
6061                 NodeParam0   Content
6062                 NodeParam2   uint8
6063                 NodeTile     uint8
6064         }))(obj)).ExpirationTime {
6065                 {
6066                         x := ((*(*(struct {
6067                                 Amount         uint16
6068                                 Duration       float32
6069                                 Pos, Vel, Acc  [2][3]float32
6070                                 ExpirationTime [2]float32 // in seconds.
6071                                 Size           [2]float32
6072                                 Collide        bool
6073
6074                                 //mt:len32
6075                                 Texture
6076
6077                                 ID           ParticleSpawnerID
6078                                 Vertical     bool
6079                                 CollisionRm  bool
6080                                 AttachedAOID AOID
6081                                 AnimParams   TileAnim
6082                                 Glow         uint8
6083                                 AOCollision  bool
6084                                 NodeParam0   Content
6085                                 NodeParam2   uint8
6086                                 NodeTile     uint8
6087                         }))(obj)).ExpirationTime)[local160]
6088                         write32(w, math.Float32bits(x))
6089                 }
6090         }
6091         for local161 := range (*(*(struct {
6092                 Amount         uint16
6093                 Duration       float32
6094                 Pos, Vel, Acc  [2][3]float32
6095                 ExpirationTime [2]float32 // in seconds.
6096                 Size           [2]float32
6097                 Collide        bool
6098
6099                 //mt:len32
6100                 Texture
6101
6102                 ID           ParticleSpawnerID
6103                 Vertical     bool
6104                 CollisionRm  bool
6105                 AttachedAOID AOID
6106                 AnimParams   TileAnim
6107                 Glow         uint8
6108                 AOCollision  bool
6109                 NodeParam0   Content
6110                 NodeParam2   uint8
6111                 NodeTile     uint8
6112         }))(obj)).Size {
6113                 {
6114                         x := ((*(*(struct {
6115                                 Amount         uint16
6116                                 Duration       float32
6117                                 Pos, Vel, Acc  [2][3]float32
6118                                 ExpirationTime [2]float32 // in seconds.
6119                                 Size           [2]float32
6120                                 Collide        bool
6121
6122                                 //mt:len32
6123                                 Texture
6124
6125                                 ID           ParticleSpawnerID
6126                                 Vertical     bool
6127                                 CollisionRm  bool
6128                                 AttachedAOID AOID
6129                                 AnimParams   TileAnim
6130                                 Glow         uint8
6131                                 AOCollision  bool
6132                                 NodeParam0   Content
6133                                 NodeParam2   uint8
6134                                 NodeTile     uint8
6135                         }))(obj)).Size)[local161]
6136                         write32(w, math.Float32bits(x))
6137                 }
6138         }
6139         {
6140                 x := (*(*(struct {
6141                         Amount         uint16
6142                         Duration       float32
6143                         Pos, Vel, Acc  [2][3]float32
6144                         ExpirationTime [2]float32 // in seconds.
6145                         Size           [2]float32
6146                         Collide        bool
6147
6148                         //mt:len32
6149                         Texture
6150
6151                         ID           ParticleSpawnerID
6152                         Vertical     bool
6153                         CollisionRm  bool
6154                         AttachedAOID AOID
6155                         AnimParams   TileAnim
6156                         Glow         uint8
6157                         AOCollision  bool
6158                         NodeParam0   Content
6159                         NodeParam2   uint8
6160                         NodeTile     uint8
6161                 }))(obj)).Collide
6162                 if x {
6163                         write8(w, 1)
6164                 } else {
6165                         write8(w, 0)
6166                 }
6167
6168         }
6169         if len(([]byte(*(*string)(&((*(*(struct {
6170                 Amount         uint16
6171                 Duration       float32
6172                 Pos, Vel, Acc  [2][3]float32
6173                 ExpirationTime [2]float32 // in seconds.
6174                 Size           [2]float32
6175                 Collide        bool
6176
6177                 //mt:len32
6178                 Texture
6179
6180                 ID           ParticleSpawnerID
6181                 Vertical     bool
6182                 CollisionRm  bool
6183                 AttachedAOID AOID
6184                 AnimParams   TileAnim
6185                 Glow         uint8
6186                 AOCollision  bool
6187                 NodeParam0   Content
6188                 NodeParam2   uint8
6189                 NodeTile     uint8
6190         }))(obj)).Texture))))) > math.MaxUint32 {
6191                 chk(ErrTooLong)
6192         }
6193         {
6194                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6195                         Amount         uint16
6196                         Duration       float32
6197                         Pos, Vel, Acc  [2][3]float32
6198                         ExpirationTime [2]float32 // in seconds.
6199                         Size           [2]float32
6200                         Collide        bool
6201
6202                         //mt:len32
6203                         Texture
6204
6205                         ID           ParticleSpawnerID
6206                         Vertical     bool
6207                         CollisionRm  bool
6208                         AttachedAOID AOID
6209                         AnimParams   TileAnim
6210                         Glow         uint8
6211                         AOCollision  bool
6212                         NodeParam0   Content
6213                         NodeParam2   uint8
6214                         NodeTile     uint8
6215                 }))(obj)).Texture))))))
6216                 write32(w, uint32(x))
6217         }
6218         {
6219                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6220                         Amount         uint16
6221                         Duration       float32
6222                         Pos, Vel, Acc  [2][3]float32
6223                         ExpirationTime [2]float32 // in seconds.
6224                         Size           [2]float32
6225                         Collide        bool
6226
6227                         //mt:len32
6228                         Texture
6229
6230                         ID           ParticleSpawnerID
6231                         Vertical     bool
6232                         CollisionRm  bool
6233                         AttachedAOID AOID
6234                         AnimParams   TileAnim
6235                         Glow         uint8
6236                         AOCollision  bool
6237                         NodeParam0   Content
6238                         NodeParam2   uint8
6239                         NodeTile     uint8
6240                 }))(obj)).Texture))))[:])
6241                 chk(err)
6242         }
6243         if err := pcall(func() {
6244                 ((*(*(struct {
6245                         Amount         uint16
6246                         Duration       float32
6247                         Pos, Vel, Acc  [2][3]float32
6248                         ExpirationTime [2]float32 // in seconds.
6249                         Size           [2]float32
6250                         Collide        bool
6251
6252                         //mt:len32
6253                         Texture
6254
6255                         ID           ParticleSpawnerID
6256                         Vertical     bool
6257                         CollisionRm  bool
6258                         AttachedAOID AOID
6259                         AnimParams   TileAnim
6260                         Glow         uint8
6261                         AOCollision  bool
6262                         NodeParam0   Content
6263                         NodeParam2   uint8
6264                         NodeTile     uint8
6265                 }))(obj)).ID).serialize(w)
6266         }); err != nil {
6267                 if err == io.EOF {
6268                         chk(io.EOF)
6269                 }
6270                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
6271         }
6272         {
6273                 x := (*(*(struct {
6274                         Amount         uint16
6275                         Duration       float32
6276                         Pos, Vel, Acc  [2][3]float32
6277                         ExpirationTime [2]float32 // in seconds.
6278                         Size           [2]float32
6279                         Collide        bool
6280
6281                         //mt:len32
6282                         Texture
6283
6284                         ID           ParticleSpawnerID
6285                         Vertical     bool
6286                         CollisionRm  bool
6287                         AttachedAOID AOID
6288                         AnimParams   TileAnim
6289                         Glow         uint8
6290                         AOCollision  bool
6291                         NodeParam0   Content
6292                         NodeParam2   uint8
6293                         NodeTile     uint8
6294                 }))(obj)).Vertical
6295                 if x {
6296                         write8(w, 1)
6297                 } else {
6298                         write8(w, 0)
6299                 }
6300
6301         }
6302         {
6303                 x := (*(*(struct {
6304                         Amount         uint16
6305                         Duration       float32
6306                         Pos, Vel, Acc  [2][3]float32
6307                         ExpirationTime [2]float32 // in seconds.
6308                         Size           [2]float32
6309                         Collide        bool
6310
6311                         //mt:len32
6312                         Texture
6313
6314                         ID           ParticleSpawnerID
6315                         Vertical     bool
6316                         CollisionRm  bool
6317                         AttachedAOID AOID
6318                         AnimParams   TileAnim
6319                         Glow         uint8
6320                         AOCollision  bool
6321                         NodeParam0   Content
6322                         NodeParam2   uint8
6323                         NodeTile     uint8
6324                 }))(obj)).CollisionRm
6325                 if x {
6326                         write8(w, 1)
6327                 } else {
6328                         write8(w, 0)
6329                 }
6330
6331         }
6332         if err := pcall(func() {
6333                 ((*(*(struct {
6334                         Amount         uint16
6335                         Duration       float32
6336                         Pos, Vel, Acc  [2][3]float32
6337                         ExpirationTime [2]float32 // in seconds.
6338                         Size           [2]float32
6339                         Collide        bool
6340
6341                         //mt:len32
6342                         Texture
6343
6344                         ID           ParticleSpawnerID
6345                         Vertical     bool
6346                         CollisionRm  bool
6347                         AttachedAOID AOID
6348                         AnimParams   TileAnim
6349                         Glow         uint8
6350                         AOCollision  bool
6351                         NodeParam0   Content
6352                         NodeParam2   uint8
6353                         NodeTile     uint8
6354                 }))(obj)).AttachedAOID).serialize(w)
6355         }); err != nil {
6356                 if err == io.EOF {
6357                         chk(io.EOF)
6358                 }
6359                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
6360         }
6361         if err := pcall(func() {
6362                 ((*(*(struct {
6363                         Amount         uint16
6364                         Duration       float32
6365                         Pos, Vel, Acc  [2][3]float32
6366                         ExpirationTime [2]float32 // in seconds.
6367                         Size           [2]float32
6368                         Collide        bool
6369
6370                         //mt:len32
6371                         Texture
6372
6373                         ID           ParticleSpawnerID
6374                         Vertical     bool
6375                         CollisionRm  bool
6376                         AttachedAOID AOID
6377                         AnimParams   TileAnim
6378                         Glow         uint8
6379                         AOCollision  bool
6380                         NodeParam0   Content
6381                         NodeParam2   uint8
6382                         NodeTile     uint8
6383                 }))(obj)).AnimParams).serialize(w)
6384         }); err != nil {
6385                 if err == io.EOF {
6386                         chk(io.EOF)
6387                 }
6388                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
6389         }
6390         {
6391                 x := (*(*(struct {
6392                         Amount         uint16
6393                         Duration       float32
6394                         Pos, Vel, Acc  [2][3]float32
6395                         ExpirationTime [2]float32 // in seconds.
6396                         Size           [2]float32
6397                         Collide        bool
6398
6399                         //mt:len32
6400                         Texture
6401
6402                         ID           ParticleSpawnerID
6403                         Vertical     bool
6404                         CollisionRm  bool
6405                         AttachedAOID AOID
6406                         AnimParams   TileAnim
6407                         Glow         uint8
6408                         AOCollision  bool
6409                         NodeParam0   Content
6410                         NodeParam2   uint8
6411                         NodeTile     uint8
6412                 }))(obj)).Glow
6413                 write8(w, uint8(x))
6414         }
6415         {
6416                 x := (*(*(struct {
6417                         Amount         uint16
6418                         Duration       float32
6419                         Pos, Vel, Acc  [2][3]float32
6420                         ExpirationTime [2]float32 // in seconds.
6421                         Size           [2]float32
6422                         Collide        bool
6423
6424                         //mt:len32
6425                         Texture
6426
6427                         ID           ParticleSpawnerID
6428                         Vertical     bool
6429                         CollisionRm  bool
6430                         AttachedAOID AOID
6431                         AnimParams   TileAnim
6432                         Glow         uint8
6433                         AOCollision  bool
6434                         NodeParam0   Content
6435                         NodeParam2   uint8
6436                         NodeTile     uint8
6437                 }))(obj)).AOCollision
6438                 if x {
6439                         write8(w, 1)
6440                 } else {
6441                         write8(w, 0)
6442                 }
6443
6444         }
6445         if err := pcall(func() {
6446                 ((*(*(struct {
6447                         Amount         uint16
6448                         Duration       float32
6449                         Pos, Vel, Acc  [2][3]float32
6450                         ExpirationTime [2]float32 // in seconds.
6451                         Size           [2]float32
6452                         Collide        bool
6453
6454                         //mt:len32
6455                         Texture
6456
6457                         ID           ParticleSpawnerID
6458                         Vertical     bool
6459                         CollisionRm  bool
6460                         AttachedAOID AOID
6461                         AnimParams   TileAnim
6462                         Glow         uint8
6463                         AOCollision  bool
6464                         NodeParam0   Content
6465                         NodeParam2   uint8
6466                         NodeTile     uint8
6467                 }))(obj)).NodeParam0).serialize(w)
6468         }); err != nil {
6469                 if err == io.EOF {
6470                         chk(io.EOF)
6471                 }
6472                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
6473         }
6474         {
6475                 x := (*(*(struct {
6476                         Amount         uint16
6477                         Duration       float32
6478                         Pos, Vel, Acc  [2][3]float32
6479                         ExpirationTime [2]float32 // in seconds.
6480                         Size           [2]float32
6481                         Collide        bool
6482
6483                         //mt:len32
6484                         Texture
6485
6486                         ID           ParticleSpawnerID
6487                         Vertical     bool
6488                         CollisionRm  bool
6489                         AttachedAOID AOID
6490                         AnimParams   TileAnim
6491                         Glow         uint8
6492                         AOCollision  bool
6493                         NodeParam0   Content
6494                         NodeParam2   uint8
6495                         NodeTile     uint8
6496                 }))(obj)).NodeParam2
6497                 write8(w, uint8(x))
6498         }
6499         {
6500                 x := (*(*(struct {
6501                         Amount         uint16
6502                         Duration       float32
6503                         Pos, Vel, Acc  [2][3]float32
6504                         ExpirationTime [2]float32 // in seconds.
6505                         Size           [2]float32
6506                         Collide        bool
6507
6508                         //mt:len32
6509                         Texture
6510
6511                         ID           ParticleSpawnerID
6512                         Vertical     bool
6513                         CollisionRm  bool
6514                         AttachedAOID AOID
6515                         AnimParams   TileAnim
6516                         Glow         uint8
6517                         AOCollision  bool
6518                         NodeParam0   Content
6519                         NodeParam2   uint8
6520                         NodeTile     uint8
6521                 }))(obj)).NodeTile
6522                 write8(w, uint8(x))
6523         }
6524 }
6525
6526 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6527         {
6528                 p := &(*(*(struct {
6529                         Amount         uint16
6530                         Duration       float32
6531                         Pos, Vel, Acc  [2][3]float32
6532                         ExpirationTime [2]float32 // in seconds.
6533                         Size           [2]float32
6534                         Collide        bool
6535
6536                         //mt:len32
6537                         Texture
6538
6539                         ID           ParticleSpawnerID
6540                         Vertical     bool
6541                         CollisionRm  bool
6542                         AttachedAOID AOID
6543                         AnimParams   TileAnim
6544                         Glow         uint8
6545                         AOCollision  bool
6546                         NodeParam0   Content
6547                         NodeParam2   uint8
6548                         NodeTile     uint8
6549                 }))(obj)).Amount
6550                 *p = read16(r)
6551         }
6552         {
6553                 p := &(*(*(struct {
6554                         Amount         uint16
6555                         Duration       float32
6556                         Pos, Vel, Acc  [2][3]float32
6557                         ExpirationTime [2]float32 // in seconds.
6558                         Size           [2]float32
6559                         Collide        bool
6560
6561                         //mt:len32
6562                         Texture
6563
6564                         ID           ParticleSpawnerID
6565                         Vertical     bool
6566                         CollisionRm  bool
6567                         AttachedAOID AOID
6568                         AnimParams   TileAnim
6569                         Glow         uint8
6570                         AOCollision  bool
6571                         NodeParam0   Content
6572                         NodeParam2   uint8
6573                         NodeTile     uint8
6574                 }))(obj)).Duration
6575                 *p = math.Float32frombits(read32(r))
6576         }
6577         for local162 := range (*(*(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 {
6599                 for local163 := range ((*(*(struct {
6600                         Amount         uint16
6601                         Duration       float32
6602                         Pos, Vel, Acc  [2][3]float32
6603                         ExpirationTime [2]float32 // in seconds.
6604                         Size           [2]float32
6605                         Collide        bool
6606
6607                         //mt:len32
6608                         Texture
6609
6610                         ID           ParticleSpawnerID
6611                         Vertical     bool
6612                         CollisionRm  bool
6613                         AttachedAOID AOID
6614                         AnimParams   TileAnim
6615                         Glow         uint8
6616                         AOCollision  bool
6617                         NodeParam0   Content
6618                         NodeParam2   uint8
6619                         NodeTile     uint8
6620                 }))(obj)).Pos)[local162] {
6621                         {
6622                                 p := &(((*(*(struct {
6623                                         Amount         uint16
6624                                         Duration       float32
6625                                         Pos, Vel, Acc  [2][3]float32
6626                                         ExpirationTime [2]float32 // in seconds.
6627                                         Size           [2]float32
6628                                         Collide        bool
6629
6630                                         //mt:len32
6631                                         Texture
6632
6633                                         ID           ParticleSpawnerID
6634                                         Vertical     bool
6635                                         CollisionRm  bool
6636                                         AttachedAOID AOID
6637                                         AnimParams   TileAnim
6638                                         Glow         uint8
6639                                         AOCollision  bool
6640                                         NodeParam0   Content
6641                                         NodeParam2   uint8
6642                                         NodeTile     uint8
6643                                 }))(obj)).Pos)[local162])[local163]
6644                                 *p = math.Float32frombits(read32(r))
6645                         }
6646                 }
6647         }
6648         for local164 := range (*(*(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 {
6670                 for local165 := range ((*(*(struct {
6671                         Amount         uint16
6672                         Duration       float32
6673                         Pos, Vel, Acc  [2][3]float32
6674                         ExpirationTime [2]float32 // in seconds.
6675                         Size           [2]float32
6676                         Collide        bool
6677
6678                         //mt:len32
6679                         Texture
6680
6681                         ID           ParticleSpawnerID
6682                         Vertical     bool
6683                         CollisionRm  bool
6684                         AttachedAOID AOID
6685                         AnimParams   TileAnim
6686                         Glow         uint8
6687                         AOCollision  bool
6688                         NodeParam0   Content
6689                         NodeParam2   uint8
6690                         NodeTile     uint8
6691                 }))(obj)).Vel)[local164] {
6692                         {
6693                                 p := &(((*(*(struct {
6694                                         Amount         uint16
6695                                         Duration       float32
6696                                         Pos, Vel, Acc  [2][3]float32
6697                                         ExpirationTime [2]float32 // in seconds.
6698                                         Size           [2]float32
6699                                         Collide        bool
6700
6701                                         //mt:len32
6702                                         Texture
6703
6704                                         ID           ParticleSpawnerID
6705                                         Vertical     bool
6706                                         CollisionRm  bool
6707                                         AttachedAOID AOID
6708                                         AnimParams   TileAnim
6709                                         Glow         uint8
6710                                         AOCollision  bool
6711                                         NodeParam0   Content
6712                                         NodeParam2   uint8
6713                                         NodeTile     uint8
6714                                 }))(obj)).Vel)[local164])[local165]
6715                                 *p = math.Float32frombits(read32(r))
6716                         }
6717                 }
6718         }
6719         for local166 := range (*(*(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 {
6741                 for local167 := range ((*(*(struct {
6742                         Amount         uint16
6743                         Duration       float32
6744                         Pos, Vel, Acc  [2][3]float32
6745                         ExpirationTime [2]float32 // in seconds.
6746                         Size           [2]float32
6747                         Collide        bool
6748
6749                         //mt:len32
6750                         Texture
6751
6752                         ID           ParticleSpawnerID
6753                         Vertical     bool
6754                         CollisionRm  bool
6755                         AttachedAOID AOID
6756                         AnimParams   TileAnim
6757                         Glow         uint8
6758                         AOCollision  bool
6759                         NodeParam0   Content
6760                         NodeParam2   uint8
6761                         NodeTile     uint8
6762                 }))(obj)).Acc)[local166] {
6763                         {
6764                                 p := &(((*(*(struct {
6765                                         Amount         uint16
6766                                         Duration       float32
6767                                         Pos, Vel, Acc  [2][3]float32
6768                                         ExpirationTime [2]float32 // in seconds.
6769                                         Size           [2]float32
6770                                         Collide        bool
6771
6772                                         //mt:len32
6773                                         Texture
6774
6775                                         ID           ParticleSpawnerID
6776                                         Vertical     bool
6777                                         CollisionRm  bool
6778                                         AttachedAOID AOID
6779                                         AnimParams   TileAnim
6780                                         Glow         uint8
6781                                         AOCollision  bool
6782                                         NodeParam0   Content
6783                                         NodeParam2   uint8
6784                                         NodeTile     uint8
6785                                 }))(obj)).Acc)[local166])[local167]
6786                                 *p = math.Float32frombits(read32(r))
6787                         }
6788                 }
6789         }
6790         for local168 := range (*(*(struct {
6791                 Amount         uint16
6792                 Duration       float32
6793                 Pos, Vel, Acc  [2][3]float32
6794                 ExpirationTime [2]float32 // in seconds.
6795                 Size           [2]float32
6796                 Collide        bool
6797
6798                 //mt:len32
6799                 Texture
6800
6801                 ID           ParticleSpawnerID
6802                 Vertical     bool
6803                 CollisionRm  bool
6804                 AttachedAOID AOID
6805                 AnimParams   TileAnim
6806                 Glow         uint8
6807                 AOCollision  bool
6808                 NodeParam0   Content
6809                 NodeParam2   uint8
6810                 NodeTile     uint8
6811         }))(obj)).ExpirationTime {
6812                 {
6813                         p := &((*(*(struct {
6814                                 Amount         uint16
6815                                 Duration       float32
6816                                 Pos, Vel, Acc  [2][3]float32
6817                                 ExpirationTime [2]float32 // in seconds.
6818                                 Size           [2]float32
6819                                 Collide        bool
6820
6821                                 //mt:len32
6822                                 Texture
6823
6824                                 ID           ParticleSpawnerID
6825                                 Vertical     bool
6826                                 CollisionRm  bool
6827                                 AttachedAOID AOID
6828                                 AnimParams   TileAnim
6829                                 Glow         uint8
6830                                 AOCollision  bool
6831                                 NodeParam0   Content
6832                                 NodeParam2   uint8
6833                                 NodeTile     uint8
6834                         }))(obj)).ExpirationTime)[local168]
6835                         *p = math.Float32frombits(read32(r))
6836                 }
6837         }
6838         for local169 := range (*(*(struct {
6839                 Amount         uint16
6840                 Duration       float32
6841                 Pos, Vel, Acc  [2][3]float32
6842                 ExpirationTime [2]float32 // in seconds.
6843                 Size           [2]float32
6844                 Collide        bool
6845
6846                 //mt:len32
6847                 Texture
6848
6849                 ID           ParticleSpawnerID
6850                 Vertical     bool
6851                 CollisionRm  bool
6852                 AttachedAOID AOID
6853                 AnimParams   TileAnim
6854                 Glow         uint8
6855                 AOCollision  bool
6856                 NodeParam0   Content
6857                 NodeParam2   uint8
6858                 NodeTile     uint8
6859         }))(obj)).Size {
6860                 {
6861                         p := &((*(*(struct {
6862                                 Amount         uint16
6863                                 Duration       float32
6864                                 Pos, Vel, Acc  [2][3]float32
6865                                 ExpirationTime [2]float32 // in seconds.
6866                                 Size           [2]float32
6867                                 Collide        bool
6868
6869                                 //mt:len32
6870                                 Texture
6871
6872                                 ID           ParticleSpawnerID
6873                                 Vertical     bool
6874                                 CollisionRm  bool
6875                                 AttachedAOID AOID
6876                                 AnimParams   TileAnim
6877                                 Glow         uint8
6878                                 AOCollision  bool
6879                                 NodeParam0   Content
6880                                 NodeParam2   uint8
6881                                 NodeTile     uint8
6882                         }))(obj)).Size)[local169]
6883                         *p = math.Float32frombits(read32(r))
6884                 }
6885         }
6886         {
6887                 p := &(*(*(struct {
6888                         Amount         uint16
6889                         Duration       float32
6890                         Pos, Vel, Acc  [2][3]float32
6891                         ExpirationTime [2]float32 // in seconds.
6892                         Size           [2]float32
6893                         Collide        bool
6894
6895                         //mt:len32
6896                         Texture
6897
6898                         ID           ParticleSpawnerID
6899                         Vertical     bool
6900                         CollisionRm  bool
6901                         AttachedAOID AOID
6902                         AnimParams   TileAnim
6903                         Glow         uint8
6904                         AOCollision  bool
6905                         NodeParam0   Content
6906                         NodeParam2   uint8
6907                         NodeTile     uint8
6908                 }))(obj)).Collide
6909                 switch n := read8(r); n {
6910                 case 0:
6911                         *p = false
6912                 case 1:
6913                         *p = true
6914                 default:
6915                         chk(fmt.Errorf("invalid bool: %d", n))
6916                 }
6917
6918         }
6919         var local170 []uint8
6920         var local171 uint32
6921         {
6922                 p := &local171
6923                 *p = read32(r)
6924         }
6925         (local170) = make([]uint8, local171)
6926         {
6927                 _, err := io.ReadFull(r, (local170)[:])
6928                 chk(err)
6929         }
6930         (*(*string)(&((*(*(struct {
6931                 Amount         uint16
6932                 Duration       float32
6933                 Pos, Vel, Acc  [2][3]float32
6934                 ExpirationTime [2]float32 // in seconds.
6935                 Size           [2]float32
6936                 Collide        bool
6937
6938                 //mt:len32
6939                 Texture
6940
6941                 ID           ParticleSpawnerID
6942                 Vertical     bool
6943                 CollisionRm  bool
6944                 AttachedAOID AOID
6945                 AnimParams   TileAnim
6946                 Glow         uint8
6947                 AOCollision  bool
6948                 NodeParam0   Content
6949                 NodeParam2   uint8
6950                 NodeTile     uint8
6951         }))(obj)).Texture))) = string(local170)
6952         if err := pcall(func() {
6953                 ((*(*(struct {
6954                         Amount         uint16
6955                         Duration       float32
6956                         Pos, Vel, Acc  [2][3]float32
6957                         ExpirationTime [2]float32 // in seconds.
6958                         Size           [2]float32
6959                         Collide        bool
6960
6961                         //mt:len32
6962                         Texture
6963
6964                         ID           ParticleSpawnerID
6965                         Vertical     bool
6966                         CollisionRm  bool
6967                         AttachedAOID AOID
6968                         AnimParams   TileAnim
6969                         Glow         uint8
6970                         AOCollision  bool
6971                         NodeParam0   Content
6972                         NodeParam2   uint8
6973                         NodeTile     uint8
6974                 }))(obj)).ID).deserialize(r)
6975         }); err != nil {
6976                 if err == io.EOF {
6977                         chk(io.EOF)
6978                 }
6979                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
6980         }
6981         {
6982                 p := &(*(*(struct {
6983                         Amount         uint16
6984                         Duration       float32
6985                         Pos, Vel, Acc  [2][3]float32
6986                         ExpirationTime [2]float32 // in seconds.
6987                         Size           [2]float32
6988                         Collide        bool
6989
6990                         //mt:len32
6991                         Texture
6992
6993                         ID           ParticleSpawnerID
6994                         Vertical     bool
6995                         CollisionRm  bool
6996                         AttachedAOID AOID
6997                         AnimParams   TileAnim
6998                         Glow         uint8
6999                         AOCollision  bool
7000                         NodeParam0   Content
7001                         NodeParam2   uint8
7002                         NodeTile     uint8
7003                 }))(obj)).Vertical
7004                 switch n := read8(r); n {
7005                 case 0:
7006                         *p = false
7007                 case 1:
7008                         *p = true
7009                 default:
7010                         chk(fmt.Errorf("invalid bool: %d", n))
7011                 }
7012
7013         }
7014         {
7015                 p := &(*(*(struct {
7016                         Amount         uint16
7017                         Duration       float32
7018                         Pos, Vel, Acc  [2][3]float32
7019                         ExpirationTime [2]float32 // in seconds.
7020                         Size           [2]float32
7021                         Collide        bool
7022
7023                         //mt:len32
7024                         Texture
7025
7026                         ID           ParticleSpawnerID
7027                         Vertical     bool
7028                         CollisionRm  bool
7029                         AttachedAOID AOID
7030                         AnimParams   TileAnim
7031                         Glow         uint8
7032                         AOCollision  bool
7033                         NodeParam0   Content
7034                         NodeParam2   uint8
7035                         NodeTile     uint8
7036                 }))(obj)).CollisionRm
7037                 switch n := read8(r); n {
7038                 case 0:
7039                         *p = false
7040                 case 1:
7041                         *p = true
7042                 default:
7043                         chk(fmt.Errorf("invalid bool: %d", n))
7044                 }
7045
7046         }
7047         if err := pcall(func() {
7048                 ((*(*(struct {
7049                         Amount         uint16
7050                         Duration       float32
7051                         Pos, Vel, Acc  [2][3]float32
7052                         ExpirationTime [2]float32 // in seconds.
7053                         Size           [2]float32
7054                         Collide        bool
7055
7056                         //mt:len32
7057                         Texture
7058
7059                         ID           ParticleSpawnerID
7060                         Vertical     bool
7061                         CollisionRm  bool
7062                         AttachedAOID AOID
7063                         AnimParams   TileAnim
7064                         Glow         uint8
7065                         AOCollision  bool
7066                         NodeParam0   Content
7067                         NodeParam2   uint8
7068                         NodeTile     uint8
7069                 }))(obj)).AttachedAOID).deserialize(r)
7070         }); err != nil {
7071                 if err == io.EOF {
7072                         chk(io.EOF)
7073                 }
7074                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
7075         }
7076         if err := pcall(func() {
7077                 ((*(*(struct {
7078                         Amount         uint16
7079                         Duration       float32
7080                         Pos, Vel, Acc  [2][3]float32
7081                         ExpirationTime [2]float32 // in seconds.
7082                         Size           [2]float32
7083                         Collide        bool
7084
7085                         //mt:len32
7086                         Texture
7087
7088                         ID           ParticleSpawnerID
7089                         Vertical     bool
7090                         CollisionRm  bool
7091                         AttachedAOID AOID
7092                         AnimParams   TileAnim
7093                         Glow         uint8
7094                         AOCollision  bool
7095                         NodeParam0   Content
7096                         NodeParam2   uint8
7097                         NodeTile     uint8
7098                 }))(obj)).AnimParams).deserialize(r)
7099         }); err != nil {
7100                 if err == io.EOF {
7101                         chk(io.EOF)
7102                 }
7103                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
7104         }
7105         {
7106                 p := &(*(*(struct {
7107                         Amount         uint16
7108                         Duration       float32
7109                         Pos, Vel, Acc  [2][3]float32
7110                         ExpirationTime [2]float32 // in seconds.
7111                         Size           [2]float32
7112                         Collide        bool
7113
7114                         //mt:len32
7115                         Texture
7116
7117                         ID           ParticleSpawnerID
7118                         Vertical     bool
7119                         CollisionRm  bool
7120                         AttachedAOID AOID
7121                         AnimParams   TileAnim
7122                         Glow         uint8
7123                         AOCollision  bool
7124                         NodeParam0   Content
7125                         NodeParam2   uint8
7126                         NodeTile     uint8
7127                 }))(obj)).Glow
7128                 *p = read8(r)
7129         }
7130         {
7131                 p := &(*(*(struct {
7132                         Amount         uint16
7133                         Duration       float32
7134                         Pos, Vel, Acc  [2][3]float32
7135                         ExpirationTime [2]float32 // in seconds.
7136                         Size           [2]float32
7137                         Collide        bool
7138
7139                         //mt:len32
7140                         Texture
7141
7142                         ID           ParticleSpawnerID
7143                         Vertical     bool
7144                         CollisionRm  bool
7145                         AttachedAOID AOID
7146                         AnimParams   TileAnim
7147                         Glow         uint8
7148                         AOCollision  bool
7149                         NodeParam0   Content
7150                         NodeParam2   uint8
7151                         NodeTile     uint8
7152                 }))(obj)).AOCollision
7153                 switch n := read8(r); n {
7154                 case 0:
7155                         *p = false
7156                 case 1:
7157                         *p = true
7158                 default:
7159                         chk(fmt.Errorf("invalid bool: %d", n))
7160                 }
7161
7162         }
7163         if err := pcall(func() {
7164                 ((*(*(struct {
7165                         Amount         uint16
7166                         Duration       float32
7167                         Pos, Vel, Acc  [2][3]float32
7168                         ExpirationTime [2]float32 // in seconds.
7169                         Size           [2]float32
7170                         Collide        bool
7171
7172                         //mt:len32
7173                         Texture
7174
7175                         ID           ParticleSpawnerID
7176                         Vertical     bool
7177                         CollisionRm  bool
7178                         AttachedAOID AOID
7179                         AnimParams   TileAnim
7180                         Glow         uint8
7181                         AOCollision  bool
7182                         NodeParam0   Content
7183                         NodeParam2   uint8
7184                         NodeTile     uint8
7185                 }))(obj)).NodeParam0).deserialize(r)
7186         }); err != nil {
7187                 if err == io.EOF {
7188                         chk(io.EOF)
7189                 }
7190                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
7191         }
7192         {
7193                 p := &(*(*(struct {
7194                         Amount         uint16
7195                         Duration       float32
7196                         Pos, Vel, Acc  [2][3]float32
7197                         ExpirationTime [2]float32 // in seconds.
7198                         Size           [2]float32
7199                         Collide        bool
7200
7201                         //mt:len32
7202                         Texture
7203
7204                         ID           ParticleSpawnerID
7205                         Vertical     bool
7206                         CollisionRm  bool
7207                         AttachedAOID AOID
7208                         AnimParams   TileAnim
7209                         Glow         uint8
7210                         AOCollision  bool
7211                         NodeParam0   Content
7212                         NodeParam2   uint8
7213                         NodeTile     uint8
7214                 }))(obj)).NodeParam2
7215                 *p = read8(r)
7216         }
7217         {
7218                 p := &(*(*(struct {
7219                         Amount         uint16
7220                         Duration       float32
7221                         Pos, Vel, Acc  [2][3]float32
7222                         ExpirationTime [2]float32 // in seconds.
7223                         Size           [2]float32
7224                         Collide        bool
7225
7226                         //mt:len32
7227                         Texture
7228
7229                         ID           ParticleSpawnerID
7230                         Vertical     bool
7231                         CollisionRm  bool
7232                         AttachedAOID AOID
7233                         AnimParams   TileAnim
7234                         Glow         uint8
7235                         AOCollision  bool
7236                         NodeParam0   Content
7237                         NodeParam2   uint8
7238                         NodeTile     uint8
7239                 }))(obj)).NodeTile
7240                 *p = read8(r)
7241         }
7242 }
7243
7244 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7245         if err := pcall(func() {
7246                 ((*(*(struct {
7247                         ID HUDID
7248                         HUD
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         if err := pcall(func() {
7257                 ((*(*(struct {
7258                         ID HUDID
7259                         HUD
7260                 }))(obj)).HUD).serialize(w)
7261         }); err != nil {
7262                 if err == io.EOF {
7263                         chk(io.EOF)
7264                 }
7265                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUD", err))
7266         }
7267 }
7268
7269 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7270         if err := pcall(func() {
7271                 ((*(*(struct {
7272                         ID HUDID
7273                         HUD
7274                 }))(obj)).ID).deserialize(r)
7275         }); err != nil {
7276                 if err == io.EOF {
7277                         chk(io.EOF)
7278                 }
7279                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7280         }
7281         if err := pcall(func() {
7282                 ((*(*(struct {
7283                         ID HUDID
7284                         HUD
7285                 }))(obj)).HUD).deserialize(r)
7286         }); err != nil {
7287                 if err == io.EOF {
7288                         chk(io.EOF)
7289                 }
7290                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUD", err))
7291         }
7292 }
7293
7294 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7295         if err := pcall(func() {
7296                 ((*(*(struct {
7297                         ID HUDID
7298                 }))(obj)).ID).serialize(w)
7299         }); err != nil {
7300                 if err == io.EOF {
7301                         chk(io.EOF)
7302                 }
7303                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7304         }
7305 }
7306
7307 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7308         if err := pcall(func() {
7309                 ((*(*(struct {
7310                         ID HUDID
7311                 }))(obj)).ID).deserialize(r)
7312         }); err != nil {
7313                 if err == io.EOF {
7314                         chk(io.EOF)
7315                 }
7316                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7317         }
7318 }
7319
7320 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7321         if err := pcall(func() {
7322                 ((*(*(struct {
7323                         ID HUDID
7324
7325                         Field HUDField
7326
7327                         //mt:if %s.Field == HUDPos
7328                         Pos [2]float32
7329
7330                         //mt:if %s.Field == HUDName
7331                         Name string
7332
7333                         //mt:if %s.Field == HUDScale
7334                         Scale [2]float32
7335
7336                         //mt:if %s.Field == HUDText
7337                         Text string
7338
7339                         //mt:if %s.Field == HUDNumber
7340                         Number uint32
7341
7342                         //mt:if %s.Field == HUDItem
7343                         Item uint32
7344
7345                         //mt:if %s.Field == HUDDir
7346                         Dir uint32
7347
7348                         //mt:if %s.Field == HUDAlign
7349                         Align [2]float32
7350
7351                         //mt:if %s.Field == HUDOffset
7352                         Offset [2]float32
7353
7354                         //mt:if %s.Field == HUDWorldPos
7355                         WorldPos Pos
7356
7357                         //mt:if %s.Field == HUDSize
7358                         Size [2]int32
7359
7360                         //mt:if %s.Field == HUDZIndex
7361                         ZIndex int32
7362
7363                         //mt:if %s.Field == HUDText2
7364                         Text2 string
7365                 }))(obj)).ID).serialize(w)
7366         }); err != nil {
7367                 if err == io.EOF {
7368                         chk(io.EOF)
7369                 }
7370                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
7371         }
7372         if err := pcall(func() {
7373                 ((*(*(struct {
7374                         ID HUDID
7375
7376                         Field HUDField
7377
7378                         //mt:if %s.Field == HUDPos
7379                         Pos [2]float32
7380
7381                         //mt:if %s.Field == HUDName
7382                         Name string
7383
7384                         //mt:if %s.Field == HUDScale
7385                         Scale [2]float32
7386
7387                         //mt:if %s.Field == HUDText
7388                         Text string
7389
7390                         //mt:if %s.Field == HUDNumber
7391                         Number uint32
7392
7393                         //mt:if %s.Field == HUDItem
7394                         Item uint32
7395
7396                         //mt:if %s.Field == HUDDir
7397                         Dir uint32
7398
7399                         //mt:if %s.Field == HUDAlign
7400                         Align [2]float32
7401
7402                         //mt:if %s.Field == HUDOffset
7403                         Offset [2]float32
7404
7405                         //mt:if %s.Field == HUDWorldPos
7406                         WorldPos Pos
7407
7408                         //mt:if %s.Field == HUDSize
7409                         Size [2]int32
7410
7411                         //mt:if %s.Field == HUDZIndex
7412                         ZIndex int32
7413
7414                         //mt:if %s.Field == HUDText2
7415                         Text2 string
7416                 }))(obj)).Field).serialize(w)
7417         }); err != nil {
7418                 if err == io.EOF {
7419                         chk(io.EOF)
7420                 }
7421                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDField", err))
7422         }
7423         if !((*(*(struct {
7424                 ID HUDID
7425
7426                 Field HUDField
7427
7428                 //mt:if %s.Field == HUDPos
7429                 Pos [2]float32
7430
7431                 //mt:if %s.Field == HUDName
7432                 Name string
7433
7434                 //mt:if %s.Field == HUDScale
7435                 Scale [2]float32
7436
7437                 //mt:if %s.Field == HUDText
7438                 Text string
7439
7440                 //mt:if %s.Field == HUDNumber
7441                 Number uint32
7442
7443                 //mt:if %s.Field == HUDItem
7444                 Item uint32
7445
7446                 //mt:if %s.Field == HUDDir
7447                 Dir uint32
7448
7449                 //mt:if %s.Field == HUDAlign
7450                 Align [2]float32
7451
7452                 //mt:if %s.Field == HUDOffset
7453                 Offset [2]float32
7454
7455                 //mt:if %s.Field == HUDWorldPos
7456                 WorldPos Pos
7457
7458                 //mt:if %s.Field == HUDSize
7459                 Size [2]int32
7460
7461                 //mt:if %s.Field == HUDZIndex
7462                 ZIndex int32
7463
7464                 //mt:if %s.Field == HUDText2
7465                 Text2 string
7466         }))(obj)).Field < hudMax) {
7467                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7468         }
7469         if (*(*(struct {
7470                 ID HUDID
7471
7472                 Field HUDField
7473
7474                 //mt:if %s.Field == HUDPos
7475                 Pos [2]float32
7476
7477                 //mt:if %s.Field == HUDName
7478                 Name string
7479
7480                 //mt:if %s.Field == HUDScale
7481                 Scale [2]float32
7482
7483                 //mt:if %s.Field == HUDText
7484                 Text string
7485
7486                 //mt:if %s.Field == HUDNumber
7487                 Number uint32
7488
7489                 //mt:if %s.Field == HUDItem
7490                 Item uint32
7491
7492                 //mt:if %s.Field == HUDDir
7493                 Dir uint32
7494
7495                 //mt:if %s.Field == HUDAlign
7496                 Align [2]float32
7497
7498                 //mt:if %s.Field == HUDOffset
7499                 Offset [2]float32
7500
7501                 //mt:if %s.Field == HUDWorldPos
7502                 WorldPos Pos
7503
7504                 //mt:if %s.Field == HUDSize
7505                 Size [2]int32
7506
7507                 //mt:if %s.Field == HUDZIndex
7508                 ZIndex int32
7509
7510                 //mt:if %s.Field == HUDText2
7511                 Text2 string
7512         }))(obj)).Field == HUDPos {
7513                 for local172 := range (*(*(struct {
7514                         ID HUDID
7515
7516                         Field HUDField
7517
7518                         //mt:if %s.Field == HUDPos
7519                         Pos [2]float32
7520
7521                         //mt:if %s.Field == HUDName
7522                         Name string
7523
7524                         //mt:if %s.Field == HUDScale
7525                         Scale [2]float32
7526
7527                         //mt:if %s.Field == HUDText
7528                         Text string
7529
7530                         //mt:if %s.Field == HUDNumber
7531                         Number uint32
7532
7533                         //mt:if %s.Field == HUDItem
7534                         Item uint32
7535
7536                         //mt:if %s.Field == HUDDir
7537                         Dir uint32
7538
7539                         //mt:if %s.Field == HUDAlign
7540                         Align [2]float32
7541
7542                         //mt:if %s.Field == HUDOffset
7543                         Offset [2]float32
7544
7545                         //mt:if %s.Field == HUDWorldPos
7546                         WorldPos Pos
7547
7548                         //mt:if %s.Field == HUDSize
7549                         Size [2]int32
7550
7551                         //mt:if %s.Field == HUDZIndex
7552                         ZIndex int32
7553
7554                         //mt:if %s.Field == HUDText2
7555                         Text2 string
7556                 }))(obj)).Pos {
7557                         {
7558                                 x := ((*(*(struct {
7559                                         ID HUDID
7560
7561                                         Field HUDField
7562
7563                                         //mt:if %s.Field == HUDPos
7564                                         Pos [2]float32
7565
7566                                         //mt:if %s.Field == HUDName
7567                                         Name string
7568
7569                                         //mt:if %s.Field == HUDScale
7570                                         Scale [2]float32
7571
7572                                         //mt:if %s.Field == HUDText
7573                                         Text string
7574
7575                                         //mt:if %s.Field == HUDNumber
7576                                         Number uint32
7577
7578                                         //mt:if %s.Field == HUDItem
7579                                         Item uint32
7580
7581                                         //mt:if %s.Field == HUDDir
7582                                         Dir uint32
7583
7584                                         //mt:if %s.Field == HUDAlign
7585                                         Align [2]float32
7586
7587                                         //mt:if %s.Field == HUDOffset
7588                                         Offset [2]float32
7589
7590                                         //mt:if %s.Field == HUDWorldPos
7591                                         WorldPos Pos
7592
7593                                         //mt:if %s.Field == HUDSize
7594                                         Size [2]int32
7595
7596                                         //mt:if %s.Field == HUDZIndex
7597                                         ZIndex int32
7598
7599                                         //mt:if %s.Field == HUDText2
7600                                         Text2 string
7601                                 }))(obj)).Pos)[local172]
7602                                 write32(w, math.Float32bits(x))
7603                         }
7604                 }
7605         }
7606         if (*(*(struct {
7607                 ID HUDID
7608
7609                 Field HUDField
7610
7611                 //mt:if %s.Field == HUDPos
7612                 Pos [2]float32
7613
7614                 //mt:if %s.Field == HUDName
7615                 Name string
7616
7617                 //mt:if %s.Field == HUDScale
7618                 Scale [2]float32
7619
7620                 //mt:if %s.Field == HUDText
7621                 Text string
7622
7623                 //mt:if %s.Field == HUDNumber
7624                 Number uint32
7625
7626                 //mt:if %s.Field == HUDItem
7627                 Item uint32
7628
7629                 //mt:if %s.Field == HUDDir
7630                 Dir uint32
7631
7632                 //mt:if %s.Field == HUDAlign
7633                 Align [2]float32
7634
7635                 //mt:if %s.Field == HUDOffset
7636                 Offset [2]float32
7637
7638                 //mt:if %s.Field == HUDWorldPos
7639                 WorldPos Pos
7640
7641                 //mt:if %s.Field == HUDSize
7642                 Size [2]int32
7643
7644                 //mt:if %s.Field == HUDZIndex
7645                 ZIndex int32
7646
7647                 //mt:if %s.Field == HUDText2
7648                 Text2 string
7649         }))(obj)).Field == HUDName {
7650                 if len(([]byte((*(*(struct {
7651                         ID HUDID
7652
7653                         Field HUDField
7654
7655                         //mt:if %s.Field == HUDPos
7656                         Pos [2]float32
7657
7658                         //mt:if %s.Field == HUDName
7659                         Name string
7660
7661                         //mt:if %s.Field == HUDScale
7662                         Scale [2]float32
7663
7664                         //mt:if %s.Field == HUDText
7665                         Text string
7666
7667                         //mt:if %s.Field == HUDNumber
7668                         Number uint32
7669
7670                         //mt:if %s.Field == HUDItem
7671                         Item uint32
7672
7673                         //mt:if %s.Field == HUDDir
7674                         Dir uint32
7675
7676                         //mt:if %s.Field == HUDAlign
7677                         Align [2]float32
7678
7679                         //mt:if %s.Field == HUDOffset
7680                         Offset [2]float32
7681
7682                         //mt:if %s.Field == HUDWorldPos
7683                         WorldPos Pos
7684
7685                         //mt:if %s.Field == HUDSize
7686                         Size [2]int32
7687
7688                         //mt:if %s.Field == HUDZIndex
7689                         ZIndex int32
7690
7691                         //mt:if %s.Field == HUDText2
7692                         Text2 string
7693                 }))(obj)).Name))) > math.MaxUint16 {
7694                         chk(ErrTooLong)
7695                 }
7696                 {
7697                         x := uint16(len(([]byte((*(*(struct {
7698                                 ID HUDID
7699
7700                                 Field HUDField
7701
7702                                 //mt:if %s.Field == HUDPos
7703                                 Pos [2]float32
7704
7705                                 //mt:if %s.Field == HUDName
7706                                 Name string
7707
7708                                 //mt:if %s.Field == HUDScale
7709                                 Scale [2]float32
7710
7711                                 //mt:if %s.Field == HUDText
7712                                 Text string
7713
7714                                 //mt:if %s.Field == HUDNumber
7715                                 Number uint32
7716
7717                                 //mt:if %s.Field == HUDItem
7718                                 Item uint32
7719
7720                                 //mt:if %s.Field == HUDDir
7721                                 Dir uint32
7722
7723                                 //mt:if %s.Field == HUDAlign
7724                                 Align [2]float32
7725
7726                                 //mt:if %s.Field == HUDOffset
7727                                 Offset [2]float32
7728
7729                                 //mt:if %s.Field == HUDWorldPos
7730                                 WorldPos Pos
7731
7732                                 //mt:if %s.Field == HUDSize
7733                                 Size [2]int32
7734
7735                                 //mt:if %s.Field == HUDZIndex
7736                                 ZIndex int32
7737
7738                                 //mt:if %s.Field == HUDText2
7739                                 Text2 string
7740                         }))(obj)).Name))))
7741                         write16(w, uint16(x))
7742                 }
7743                 {
7744                         _, err := w.Write(([]byte((*(*(struct {
7745                                 ID HUDID
7746
7747                                 Field HUDField
7748
7749                                 //mt:if %s.Field == HUDPos
7750                                 Pos [2]float32
7751
7752                                 //mt:if %s.Field == HUDName
7753                                 Name string
7754
7755                                 //mt:if %s.Field == HUDScale
7756                                 Scale [2]float32
7757
7758                                 //mt:if %s.Field == HUDText
7759                                 Text string
7760
7761                                 //mt:if %s.Field == HUDNumber
7762                                 Number uint32
7763
7764                                 //mt:if %s.Field == HUDItem
7765                                 Item uint32
7766
7767                                 //mt:if %s.Field == HUDDir
7768                                 Dir uint32
7769
7770                                 //mt:if %s.Field == HUDAlign
7771                                 Align [2]float32
7772
7773                                 //mt:if %s.Field == HUDOffset
7774                                 Offset [2]float32
7775
7776                                 //mt:if %s.Field == HUDWorldPos
7777                                 WorldPos Pos
7778
7779                                 //mt:if %s.Field == HUDSize
7780                                 Size [2]int32
7781
7782                                 //mt:if %s.Field == HUDZIndex
7783                                 ZIndex int32
7784
7785                                 //mt:if %s.Field == HUDText2
7786                                 Text2 string
7787                         }))(obj)).Name))[:])
7788                         chk(err)
7789                 }
7790         }
7791         if (*(*(struct {
7792                 ID HUDID
7793
7794                 Field HUDField
7795
7796                 //mt:if %s.Field == HUDPos
7797                 Pos [2]float32
7798
7799                 //mt:if %s.Field == HUDName
7800                 Name string
7801
7802                 //mt:if %s.Field == HUDScale
7803                 Scale [2]float32
7804
7805                 //mt:if %s.Field == HUDText
7806                 Text string
7807
7808                 //mt:if %s.Field == HUDNumber
7809                 Number uint32
7810
7811                 //mt:if %s.Field == HUDItem
7812                 Item uint32
7813
7814                 //mt:if %s.Field == HUDDir
7815                 Dir uint32
7816
7817                 //mt:if %s.Field == HUDAlign
7818                 Align [2]float32
7819
7820                 //mt:if %s.Field == HUDOffset
7821                 Offset [2]float32
7822
7823                 //mt:if %s.Field == HUDWorldPos
7824                 WorldPos Pos
7825
7826                 //mt:if %s.Field == HUDSize
7827                 Size [2]int32
7828
7829                 //mt:if %s.Field == HUDZIndex
7830                 ZIndex int32
7831
7832                 //mt:if %s.Field == HUDText2
7833                 Text2 string
7834         }))(obj)).Field == HUDScale {
7835                 for local173 := range (*(*(struct {
7836                         ID HUDID
7837
7838                         Field HUDField
7839
7840                         //mt:if %s.Field == HUDPos
7841                         Pos [2]float32
7842
7843                         //mt:if %s.Field == HUDName
7844                         Name string
7845
7846                         //mt:if %s.Field == HUDScale
7847                         Scale [2]float32
7848
7849                         //mt:if %s.Field == HUDText
7850                         Text string
7851
7852                         //mt:if %s.Field == HUDNumber
7853                         Number uint32
7854
7855                         //mt:if %s.Field == HUDItem
7856                         Item uint32
7857
7858                         //mt:if %s.Field == HUDDir
7859                         Dir uint32
7860
7861                         //mt:if %s.Field == HUDAlign
7862                         Align [2]float32
7863
7864                         //mt:if %s.Field == HUDOffset
7865                         Offset [2]float32
7866
7867                         //mt:if %s.Field == HUDWorldPos
7868                         WorldPos Pos
7869
7870                         //mt:if %s.Field == HUDSize
7871                         Size [2]int32
7872
7873                         //mt:if %s.Field == HUDZIndex
7874                         ZIndex int32
7875
7876                         //mt:if %s.Field == HUDText2
7877                         Text2 string
7878                 }))(obj)).Scale {
7879                         {
7880                                 x := ((*(*(struct {
7881                                         ID HUDID
7882
7883                                         Field HUDField
7884
7885                                         //mt:if %s.Field == HUDPos
7886                                         Pos [2]float32
7887
7888                                         //mt:if %s.Field == HUDName
7889                                         Name string
7890
7891                                         //mt:if %s.Field == HUDScale
7892                                         Scale [2]float32
7893
7894                                         //mt:if %s.Field == HUDText
7895                                         Text string
7896
7897                                         //mt:if %s.Field == HUDNumber
7898                                         Number uint32
7899
7900                                         //mt:if %s.Field == HUDItem
7901                                         Item uint32
7902
7903                                         //mt:if %s.Field == HUDDir
7904                                         Dir uint32
7905
7906                                         //mt:if %s.Field == HUDAlign
7907                                         Align [2]float32
7908
7909                                         //mt:if %s.Field == HUDOffset
7910                                         Offset [2]float32
7911
7912                                         //mt:if %s.Field == HUDWorldPos
7913                                         WorldPos Pos
7914
7915                                         //mt:if %s.Field == HUDSize
7916                                         Size [2]int32
7917
7918                                         //mt:if %s.Field == HUDZIndex
7919                                         ZIndex int32
7920
7921                                         //mt:if %s.Field == HUDText2
7922                                         Text2 string
7923                                 }))(obj)).Scale)[local173]
7924                                 write32(w, math.Float32bits(x))
7925                         }
7926                 }
7927         }
7928         if (*(*(struct {
7929                 ID HUDID
7930
7931                 Field HUDField
7932
7933                 //mt:if %s.Field == HUDPos
7934                 Pos [2]float32
7935
7936                 //mt:if %s.Field == HUDName
7937                 Name string
7938
7939                 //mt:if %s.Field == HUDScale
7940                 Scale [2]float32
7941
7942                 //mt:if %s.Field == HUDText
7943                 Text string
7944
7945                 //mt:if %s.Field == HUDNumber
7946                 Number uint32
7947
7948                 //mt:if %s.Field == HUDItem
7949                 Item uint32
7950
7951                 //mt:if %s.Field == HUDDir
7952                 Dir uint32
7953
7954                 //mt:if %s.Field == HUDAlign
7955                 Align [2]float32
7956
7957                 //mt:if %s.Field == HUDOffset
7958                 Offset [2]float32
7959
7960                 //mt:if %s.Field == HUDWorldPos
7961                 WorldPos Pos
7962
7963                 //mt:if %s.Field == HUDSize
7964                 Size [2]int32
7965
7966                 //mt:if %s.Field == HUDZIndex
7967                 ZIndex int32
7968
7969                 //mt:if %s.Field == HUDText2
7970                 Text2 string
7971         }))(obj)).Field == HUDText {
7972                 if len(([]byte((*(*(struct {
7973                         ID HUDID
7974
7975                         Field HUDField
7976
7977                         //mt:if %s.Field == HUDPos
7978                         Pos [2]float32
7979
7980                         //mt:if %s.Field == HUDName
7981                         Name string
7982
7983                         //mt:if %s.Field == HUDScale
7984                         Scale [2]float32
7985
7986                         //mt:if %s.Field == HUDText
7987                         Text string
7988
7989                         //mt:if %s.Field == HUDNumber
7990                         Number uint32
7991
7992                         //mt:if %s.Field == HUDItem
7993                         Item uint32
7994
7995                         //mt:if %s.Field == HUDDir
7996                         Dir uint32
7997
7998                         //mt:if %s.Field == HUDAlign
7999                         Align [2]float32
8000
8001                         //mt:if %s.Field == HUDOffset
8002                         Offset [2]float32
8003
8004                         //mt:if %s.Field == HUDWorldPos
8005                         WorldPos Pos
8006
8007                         //mt:if %s.Field == HUDSize
8008                         Size [2]int32
8009
8010                         //mt:if %s.Field == HUDZIndex
8011                         ZIndex int32
8012
8013                         //mt:if %s.Field == HUDText2
8014                         Text2 string
8015                 }))(obj)).Text))) > math.MaxUint16 {
8016                         chk(ErrTooLong)
8017                 }
8018                 {
8019                         x := uint16(len(([]byte((*(*(struct {
8020                                 ID HUDID
8021
8022                                 Field HUDField
8023
8024                                 //mt:if %s.Field == HUDPos
8025                                 Pos [2]float32
8026
8027                                 //mt:if %s.Field == HUDName
8028                                 Name string
8029
8030                                 //mt:if %s.Field == HUDScale
8031                                 Scale [2]float32
8032
8033                                 //mt:if %s.Field == HUDText
8034                                 Text string
8035
8036                                 //mt:if %s.Field == HUDNumber
8037                                 Number uint32
8038
8039                                 //mt:if %s.Field == HUDItem
8040                                 Item uint32
8041
8042                                 //mt:if %s.Field == HUDDir
8043                                 Dir uint32
8044
8045                                 //mt:if %s.Field == HUDAlign
8046                                 Align [2]float32
8047
8048                                 //mt:if %s.Field == HUDOffset
8049                                 Offset [2]float32
8050
8051                                 //mt:if %s.Field == HUDWorldPos
8052                                 WorldPos Pos
8053
8054                                 //mt:if %s.Field == HUDSize
8055                                 Size [2]int32
8056
8057                                 //mt:if %s.Field == HUDZIndex
8058                                 ZIndex int32
8059
8060                                 //mt:if %s.Field == HUDText2
8061                                 Text2 string
8062                         }))(obj)).Text))))
8063                         write16(w, uint16(x))
8064                 }
8065                 {
8066                         _, err := w.Write(([]byte((*(*(struct {
8067                                 ID HUDID
8068
8069                                 Field HUDField
8070
8071                                 //mt:if %s.Field == HUDPos
8072                                 Pos [2]float32
8073
8074                                 //mt:if %s.Field == HUDName
8075                                 Name string
8076
8077                                 //mt:if %s.Field == HUDScale
8078                                 Scale [2]float32
8079
8080                                 //mt:if %s.Field == HUDText
8081                                 Text string
8082
8083                                 //mt:if %s.Field == HUDNumber
8084                                 Number uint32
8085
8086                                 //mt:if %s.Field == HUDItem
8087                                 Item uint32
8088
8089                                 //mt:if %s.Field == HUDDir
8090                                 Dir uint32
8091
8092                                 //mt:if %s.Field == HUDAlign
8093                                 Align [2]float32
8094
8095                                 //mt:if %s.Field == HUDOffset
8096                                 Offset [2]float32
8097
8098                                 //mt:if %s.Field == HUDWorldPos
8099                                 WorldPos Pos
8100
8101                                 //mt:if %s.Field == HUDSize
8102                                 Size [2]int32
8103
8104                                 //mt:if %s.Field == HUDZIndex
8105                                 ZIndex int32
8106
8107                                 //mt:if %s.Field == HUDText2
8108                                 Text2 string
8109                         }))(obj)).Text))[:])
8110                         chk(err)
8111                 }
8112         }
8113         if (*(*(struct {
8114                 ID HUDID
8115
8116                 Field HUDField
8117
8118                 //mt:if %s.Field == HUDPos
8119                 Pos [2]float32
8120
8121                 //mt:if %s.Field == HUDName
8122                 Name string
8123
8124                 //mt:if %s.Field == HUDScale
8125                 Scale [2]float32
8126
8127                 //mt:if %s.Field == HUDText
8128                 Text string
8129
8130                 //mt:if %s.Field == HUDNumber
8131                 Number uint32
8132
8133                 //mt:if %s.Field == HUDItem
8134                 Item uint32
8135
8136                 //mt:if %s.Field == HUDDir
8137                 Dir uint32
8138
8139                 //mt:if %s.Field == HUDAlign
8140                 Align [2]float32
8141
8142                 //mt:if %s.Field == HUDOffset
8143                 Offset [2]float32
8144
8145                 //mt:if %s.Field == HUDWorldPos
8146                 WorldPos Pos
8147
8148                 //mt:if %s.Field == HUDSize
8149                 Size [2]int32
8150
8151                 //mt:if %s.Field == HUDZIndex
8152                 ZIndex int32
8153
8154                 //mt:if %s.Field == HUDText2
8155                 Text2 string
8156         }))(obj)).Field == HUDNumber {
8157                 {
8158                         x := (*(*(struct {
8159                                 ID HUDID
8160
8161                                 Field HUDField
8162
8163                                 //mt:if %s.Field == HUDPos
8164                                 Pos [2]float32
8165
8166                                 //mt:if %s.Field == HUDName
8167                                 Name string
8168
8169                                 //mt:if %s.Field == HUDScale
8170                                 Scale [2]float32
8171
8172                                 //mt:if %s.Field == HUDText
8173                                 Text string
8174
8175                                 //mt:if %s.Field == HUDNumber
8176                                 Number uint32
8177
8178                                 //mt:if %s.Field == HUDItem
8179                                 Item uint32
8180
8181                                 //mt:if %s.Field == HUDDir
8182                                 Dir uint32
8183
8184                                 //mt:if %s.Field == HUDAlign
8185                                 Align [2]float32
8186
8187                                 //mt:if %s.Field == HUDOffset
8188                                 Offset [2]float32
8189
8190                                 //mt:if %s.Field == HUDWorldPos
8191                                 WorldPos Pos
8192
8193                                 //mt:if %s.Field == HUDSize
8194                                 Size [2]int32
8195
8196                                 //mt:if %s.Field == HUDZIndex
8197                                 ZIndex int32
8198
8199                                 //mt:if %s.Field == HUDText2
8200                                 Text2 string
8201                         }))(obj)).Number
8202                         write32(w, uint32(x))
8203                 }
8204         }
8205         if (*(*(struct {
8206                 ID HUDID
8207
8208                 Field HUDField
8209
8210                 //mt:if %s.Field == HUDPos
8211                 Pos [2]float32
8212
8213                 //mt:if %s.Field == HUDName
8214                 Name string
8215
8216                 //mt:if %s.Field == HUDScale
8217                 Scale [2]float32
8218
8219                 //mt:if %s.Field == HUDText
8220                 Text string
8221
8222                 //mt:if %s.Field == HUDNumber
8223                 Number uint32
8224
8225                 //mt:if %s.Field == HUDItem
8226                 Item uint32
8227
8228                 //mt:if %s.Field == HUDDir
8229                 Dir uint32
8230
8231                 //mt:if %s.Field == HUDAlign
8232                 Align [2]float32
8233
8234                 //mt:if %s.Field == HUDOffset
8235                 Offset [2]float32
8236
8237                 //mt:if %s.Field == HUDWorldPos
8238                 WorldPos Pos
8239
8240                 //mt:if %s.Field == HUDSize
8241                 Size [2]int32
8242
8243                 //mt:if %s.Field == HUDZIndex
8244                 ZIndex int32
8245
8246                 //mt:if %s.Field == HUDText2
8247                 Text2 string
8248         }))(obj)).Field == HUDItem {
8249                 {
8250                         x := (*(*(struct {
8251                                 ID HUDID
8252
8253                                 Field HUDField
8254
8255                                 //mt:if %s.Field == HUDPos
8256                                 Pos [2]float32
8257
8258                                 //mt:if %s.Field == HUDName
8259                                 Name string
8260
8261                                 //mt:if %s.Field == HUDScale
8262                                 Scale [2]float32
8263
8264                                 //mt:if %s.Field == HUDText
8265                                 Text string
8266
8267                                 //mt:if %s.Field == HUDNumber
8268                                 Number uint32
8269
8270                                 //mt:if %s.Field == HUDItem
8271                                 Item uint32
8272
8273                                 //mt:if %s.Field == HUDDir
8274                                 Dir uint32
8275
8276                                 //mt:if %s.Field == HUDAlign
8277                                 Align [2]float32
8278
8279                                 //mt:if %s.Field == HUDOffset
8280                                 Offset [2]float32
8281
8282                                 //mt:if %s.Field == HUDWorldPos
8283                                 WorldPos Pos
8284
8285                                 //mt:if %s.Field == HUDSize
8286                                 Size [2]int32
8287
8288                                 //mt:if %s.Field == HUDZIndex
8289                                 ZIndex int32
8290
8291                                 //mt:if %s.Field == HUDText2
8292                                 Text2 string
8293                         }))(obj)).Item
8294                         write32(w, uint32(x))
8295                 }
8296         }
8297         if (*(*(struct {
8298                 ID HUDID
8299
8300                 Field HUDField
8301
8302                 //mt:if %s.Field == HUDPos
8303                 Pos [2]float32
8304
8305                 //mt:if %s.Field == HUDName
8306                 Name string
8307
8308                 //mt:if %s.Field == HUDScale
8309                 Scale [2]float32
8310
8311                 //mt:if %s.Field == HUDText
8312                 Text string
8313
8314                 //mt:if %s.Field == HUDNumber
8315                 Number uint32
8316
8317                 //mt:if %s.Field == HUDItem
8318                 Item uint32
8319
8320                 //mt:if %s.Field == HUDDir
8321                 Dir uint32
8322
8323                 //mt:if %s.Field == HUDAlign
8324                 Align [2]float32
8325
8326                 //mt:if %s.Field == HUDOffset
8327                 Offset [2]float32
8328
8329                 //mt:if %s.Field == HUDWorldPos
8330                 WorldPos Pos
8331
8332                 //mt:if %s.Field == HUDSize
8333                 Size [2]int32
8334
8335                 //mt:if %s.Field == HUDZIndex
8336                 ZIndex int32
8337
8338                 //mt:if %s.Field == HUDText2
8339                 Text2 string
8340         }))(obj)).Field == HUDDir {
8341                 {
8342                         x := (*(*(struct {
8343                                 ID HUDID
8344
8345                                 Field HUDField
8346
8347                                 //mt:if %s.Field == HUDPos
8348                                 Pos [2]float32
8349
8350                                 //mt:if %s.Field == HUDName
8351                                 Name string
8352
8353                                 //mt:if %s.Field == HUDScale
8354                                 Scale [2]float32
8355
8356                                 //mt:if %s.Field == HUDText
8357                                 Text string
8358
8359                                 //mt:if %s.Field == HUDNumber
8360                                 Number uint32
8361
8362                                 //mt:if %s.Field == HUDItem
8363                                 Item uint32
8364
8365                                 //mt:if %s.Field == HUDDir
8366                                 Dir uint32
8367
8368                                 //mt:if %s.Field == HUDAlign
8369                                 Align [2]float32
8370
8371                                 //mt:if %s.Field == HUDOffset
8372                                 Offset [2]float32
8373
8374                                 //mt:if %s.Field == HUDWorldPos
8375                                 WorldPos Pos
8376
8377                                 //mt:if %s.Field == HUDSize
8378                                 Size [2]int32
8379
8380                                 //mt:if %s.Field == HUDZIndex
8381                                 ZIndex int32
8382
8383                                 //mt:if %s.Field == HUDText2
8384                                 Text2 string
8385                         }))(obj)).Dir
8386                         write32(w, uint32(x))
8387                 }
8388         }
8389         if (*(*(struct {
8390                 ID HUDID
8391
8392                 Field HUDField
8393
8394                 //mt:if %s.Field == HUDPos
8395                 Pos [2]float32
8396
8397                 //mt:if %s.Field == HUDName
8398                 Name string
8399
8400                 //mt:if %s.Field == HUDScale
8401                 Scale [2]float32
8402
8403                 //mt:if %s.Field == HUDText
8404                 Text string
8405
8406                 //mt:if %s.Field == HUDNumber
8407                 Number uint32
8408
8409                 //mt:if %s.Field == HUDItem
8410                 Item uint32
8411
8412                 //mt:if %s.Field == HUDDir
8413                 Dir uint32
8414
8415                 //mt:if %s.Field == HUDAlign
8416                 Align [2]float32
8417
8418                 //mt:if %s.Field == HUDOffset
8419                 Offset [2]float32
8420
8421                 //mt:if %s.Field == HUDWorldPos
8422                 WorldPos Pos
8423
8424                 //mt:if %s.Field == HUDSize
8425                 Size [2]int32
8426
8427                 //mt:if %s.Field == HUDZIndex
8428                 ZIndex int32
8429
8430                 //mt:if %s.Field == HUDText2
8431                 Text2 string
8432         }))(obj)).Field == HUDAlign {
8433                 for local174 := range (*(*(struct {
8434                         ID HUDID
8435
8436                         Field HUDField
8437
8438                         //mt:if %s.Field == HUDPos
8439                         Pos [2]float32
8440
8441                         //mt:if %s.Field == HUDName
8442                         Name string
8443
8444                         //mt:if %s.Field == HUDScale
8445                         Scale [2]float32
8446
8447                         //mt:if %s.Field == HUDText
8448                         Text string
8449
8450                         //mt:if %s.Field == HUDNumber
8451                         Number uint32
8452
8453                         //mt:if %s.Field == HUDItem
8454                         Item uint32
8455
8456                         //mt:if %s.Field == HUDDir
8457                         Dir uint32
8458
8459                         //mt:if %s.Field == HUDAlign
8460                         Align [2]float32
8461
8462                         //mt:if %s.Field == HUDOffset
8463                         Offset [2]float32
8464
8465                         //mt:if %s.Field == HUDWorldPos
8466                         WorldPos Pos
8467
8468                         //mt:if %s.Field == HUDSize
8469                         Size [2]int32
8470
8471                         //mt:if %s.Field == HUDZIndex
8472                         ZIndex int32
8473
8474                         //mt:if %s.Field == HUDText2
8475                         Text2 string
8476                 }))(obj)).Align {
8477                         {
8478                                 x := ((*(*(struct {
8479                                         ID HUDID
8480
8481                                         Field HUDField
8482
8483                                         //mt:if %s.Field == HUDPos
8484                                         Pos [2]float32
8485
8486                                         //mt:if %s.Field == HUDName
8487                                         Name string
8488
8489                                         //mt:if %s.Field == HUDScale
8490                                         Scale [2]float32
8491
8492                                         //mt:if %s.Field == HUDText
8493                                         Text string
8494
8495                                         //mt:if %s.Field == HUDNumber
8496                                         Number uint32
8497
8498                                         //mt:if %s.Field == HUDItem
8499                                         Item uint32
8500
8501                                         //mt:if %s.Field == HUDDir
8502                                         Dir uint32
8503
8504                                         //mt:if %s.Field == HUDAlign
8505                                         Align [2]float32
8506
8507                                         //mt:if %s.Field == HUDOffset
8508                                         Offset [2]float32
8509
8510                                         //mt:if %s.Field == HUDWorldPos
8511                                         WorldPos Pos
8512
8513                                         //mt:if %s.Field == HUDSize
8514                                         Size [2]int32
8515
8516                                         //mt:if %s.Field == HUDZIndex
8517                                         ZIndex int32
8518
8519                                         //mt:if %s.Field == HUDText2
8520                                         Text2 string
8521                                 }))(obj)).Align)[local174]
8522                                 write32(w, math.Float32bits(x))
8523                         }
8524                 }
8525         }
8526         if (*(*(struct {
8527                 ID HUDID
8528
8529                 Field HUDField
8530
8531                 //mt:if %s.Field == HUDPos
8532                 Pos [2]float32
8533
8534                 //mt:if %s.Field == HUDName
8535                 Name string
8536
8537                 //mt:if %s.Field == HUDScale
8538                 Scale [2]float32
8539
8540                 //mt:if %s.Field == HUDText
8541                 Text string
8542
8543                 //mt:if %s.Field == HUDNumber
8544                 Number uint32
8545
8546                 //mt:if %s.Field == HUDItem
8547                 Item uint32
8548
8549                 //mt:if %s.Field == HUDDir
8550                 Dir uint32
8551
8552                 //mt:if %s.Field == HUDAlign
8553                 Align [2]float32
8554
8555                 //mt:if %s.Field == HUDOffset
8556                 Offset [2]float32
8557
8558                 //mt:if %s.Field == HUDWorldPos
8559                 WorldPos Pos
8560
8561                 //mt:if %s.Field == HUDSize
8562                 Size [2]int32
8563
8564                 //mt:if %s.Field == HUDZIndex
8565                 ZIndex int32
8566
8567                 //mt:if %s.Field == HUDText2
8568                 Text2 string
8569         }))(obj)).Field == HUDOffset {
8570                 for local175 := range (*(*(struct {
8571                         ID HUDID
8572
8573                         Field HUDField
8574
8575                         //mt:if %s.Field == HUDPos
8576                         Pos [2]float32
8577
8578                         //mt:if %s.Field == HUDName
8579                         Name string
8580
8581                         //mt:if %s.Field == HUDScale
8582                         Scale [2]float32
8583
8584                         //mt:if %s.Field == HUDText
8585                         Text string
8586
8587                         //mt:if %s.Field == HUDNumber
8588                         Number uint32
8589
8590                         //mt:if %s.Field == HUDItem
8591                         Item uint32
8592
8593                         //mt:if %s.Field == HUDDir
8594                         Dir uint32
8595
8596                         //mt:if %s.Field == HUDAlign
8597                         Align [2]float32
8598
8599                         //mt:if %s.Field == HUDOffset
8600                         Offset [2]float32
8601
8602                         //mt:if %s.Field == HUDWorldPos
8603                         WorldPos Pos
8604
8605                         //mt:if %s.Field == HUDSize
8606                         Size [2]int32
8607
8608                         //mt:if %s.Field == HUDZIndex
8609                         ZIndex int32
8610
8611                         //mt:if %s.Field == HUDText2
8612                         Text2 string
8613                 }))(obj)).Offset {
8614                         {
8615                                 x := ((*(*(struct {
8616                                         ID HUDID
8617
8618                                         Field HUDField
8619
8620                                         //mt:if %s.Field == HUDPos
8621                                         Pos [2]float32
8622
8623                                         //mt:if %s.Field == HUDName
8624                                         Name string
8625
8626                                         //mt:if %s.Field == HUDScale
8627                                         Scale [2]float32
8628
8629                                         //mt:if %s.Field == HUDText
8630                                         Text string
8631
8632                                         //mt:if %s.Field == HUDNumber
8633                                         Number uint32
8634
8635                                         //mt:if %s.Field == HUDItem
8636                                         Item uint32
8637
8638                                         //mt:if %s.Field == HUDDir
8639                                         Dir uint32
8640
8641                                         //mt:if %s.Field == HUDAlign
8642                                         Align [2]float32
8643
8644                                         //mt:if %s.Field == HUDOffset
8645                                         Offset [2]float32
8646
8647                                         //mt:if %s.Field == HUDWorldPos
8648                                         WorldPos Pos
8649
8650                                         //mt:if %s.Field == HUDSize
8651                                         Size [2]int32
8652
8653                                         //mt:if %s.Field == HUDZIndex
8654                                         ZIndex int32
8655
8656                                         //mt:if %s.Field == HUDText2
8657                                         Text2 string
8658                                 }))(obj)).Offset)[local175]
8659                                 write32(w, math.Float32bits(x))
8660                         }
8661                 }
8662         }
8663         if (*(*(struct {
8664                 ID HUDID
8665
8666                 Field HUDField
8667
8668                 //mt:if %s.Field == HUDPos
8669                 Pos [2]float32
8670
8671                 //mt:if %s.Field == HUDName
8672                 Name string
8673
8674                 //mt:if %s.Field == HUDScale
8675                 Scale [2]float32
8676
8677                 //mt:if %s.Field == HUDText
8678                 Text string
8679
8680                 //mt:if %s.Field == HUDNumber
8681                 Number uint32
8682
8683                 //mt:if %s.Field == HUDItem
8684                 Item uint32
8685
8686                 //mt:if %s.Field == HUDDir
8687                 Dir uint32
8688
8689                 //mt:if %s.Field == HUDAlign
8690                 Align [2]float32
8691
8692                 //mt:if %s.Field == HUDOffset
8693                 Offset [2]float32
8694
8695                 //mt:if %s.Field == HUDWorldPos
8696                 WorldPos Pos
8697
8698                 //mt:if %s.Field == HUDSize
8699                 Size [2]int32
8700
8701                 //mt:if %s.Field == HUDZIndex
8702                 ZIndex int32
8703
8704                 //mt:if %s.Field == HUDText2
8705                 Text2 string
8706         }))(obj)).Field == HUDWorldPos {
8707                 if err := pcall(func() {
8708                         ((*(*(struct {
8709                                 ID HUDID
8710
8711                                 Field HUDField
8712
8713                                 //mt:if %s.Field == HUDPos
8714                                 Pos [2]float32
8715
8716                                 //mt:if %s.Field == HUDName
8717                                 Name string
8718
8719                                 //mt:if %s.Field == HUDScale
8720                                 Scale [2]float32
8721
8722                                 //mt:if %s.Field == HUDText
8723                                 Text string
8724
8725                                 //mt:if %s.Field == HUDNumber
8726                                 Number uint32
8727
8728                                 //mt:if %s.Field == HUDItem
8729                                 Item uint32
8730
8731                                 //mt:if %s.Field == HUDDir
8732                                 Dir uint32
8733
8734                                 //mt:if %s.Field == HUDAlign
8735                                 Align [2]float32
8736
8737                                 //mt:if %s.Field == HUDOffset
8738                                 Offset [2]float32
8739
8740                                 //mt:if %s.Field == HUDWorldPos
8741                                 WorldPos Pos
8742
8743                                 //mt:if %s.Field == HUDSize
8744                                 Size [2]int32
8745
8746                                 //mt:if %s.Field == HUDZIndex
8747                                 ZIndex int32
8748
8749                                 //mt:if %s.Field == HUDText2
8750                                 Text2 string
8751                         }))(obj)).WorldPos).serialize(w)
8752                 }); err != nil {
8753                         if err == io.EOF {
8754                                 chk(io.EOF)
8755                         }
8756                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
8757                 }
8758         }
8759         if (*(*(struct {
8760                 ID HUDID
8761
8762                 Field HUDField
8763
8764                 //mt:if %s.Field == HUDPos
8765                 Pos [2]float32
8766
8767                 //mt:if %s.Field == HUDName
8768                 Name string
8769
8770                 //mt:if %s.Field == HUDScale
8771                 Scale [2]float32
8772
8773                 //mt:if %s.Field == HUDText
8774                 Text string
8775
8776                 //mt:if %s.Field == HUDNumber
8777                 Number uint32
8778
8779                 //mt:if %s.Field == HUDItem
8780                 Item uint32
8781
8782                 //mt:if %s.Field == HUDDir
8783                 Dir uint32
8784
8785                 //mt:if %s.Field == HUDAlign
8786                 Align [2]float32
8787
8788                 //mt:if %s.Field == HUDOffset
8789                 Offset [2]float32
8790
8791                 //mt:if %s.Field == HUDWorldPos
8792                 WorldPos Pos
8793
8794                 //mt:if %s.Field == HUDSize
8795                 Size [2]int32
8796
8797                 //mt:if %s.Field == HUDZIndex
8798                 ZIndex int32
8799
8800                 //mt:if %s.Field == HUDText2
8801                 Text2 string
8802         }))(obj)).Field == HUDSize {
8803                 for local176 := range (*(*(struct {
8804                         ID HUDID
8805
8806                         Field HUDField
8807
8808                         //mt:if %s.Field == HUDPos
8809                         Pos [2]float32
8810
8811                         //mt:if %s.Field == HUDName
8812                         Name string
8813
8814                         //mt:if %s.Field == HUDScale
8815                         Scale [2]float32
8816
8817                         //mt:if %s.Field == HUDText
8818                         Text string
8819
8820                         //mt:if %s.Field == HUDNumber
8821                         Number uint32
8822
8823                         //mt:if %s.Field == HUDItem
8824                         Item uint32
8825
8826                         //mt:if %s.Field == HUDDir
8827                         Dir uint32
8828
8829                         //mt:if %s.Field == HUDAlign
8830                         Align [2]float32
8831
8832                         //mt:if %s.Field == HUDOffset
8833                         Offset [2]float32
8834
8835                         //mt:if %s.Field == HUDWorldPos
8836                         WorldPos Pos
8837
8838                         //mt:if %s.Field == HUDSize
8839                         Size [2]int32
8840
8841                         //mt:if %s.Field == HUDZIndex
8842                         ZIndex int32
8843
8844                         //mt:if %s.Field == HUDText2
8845                         Text2 string
8846                 }))(obj)).Size {
8847                         {
8848                                 x := ((*(*(struct {
8849                                         ID HUDID
8850
8851                                         Field HUDField
8852
8853                                         //mt:if %s.Field == HUDPos
8854                                         Pos [2]float32
8855
8856                                         //mt:if %s.Field == HUDName
8857                                         Name string
8858
8859                                         //mt:if %s.Field == HUDScale
8860                                         Scale [2]float32
8861
8862                                         //mt:if %s.Field == HUDText
8863                                         Text string
8864
8865                                         //mt:if %s.Field == HUDNumber
8866                                         Number uint32
8867
8868                                         //mt:if %s.Field == HUDItem
8869                                         Item uint32
8870
8871                                         //mt:if %s.Field == HUDDir
8872                                         Dir uint32
8873
8874                                         //mt:if %s.Field == HUDAlign
8875                                         Align [2]float32
8876
8877                                         //mt:if %s.Field == HUDOffset
8878                                         Offset [2]float32
8879
8880                                         //mt:if %s.Field == HUDWorldPos
8881                                         WorldPos Pos
8882
8883                                         //mt:if %s.Field == HUDSize
8884                                         Size [2]int32
8885
8886                                         //mt:if %s.Field == HUDZIndex
8887                                         ZIndex int32
8888
8889                                         //mt:if %s.Field == HUDText2
8890                                         Text2 string
8891                                 }))(obj)).Size)[local176]
8892                                 write32(w, uint32(x))
8893                         }
8894                 }
8895         }
8896         if (*(*(struct {
8897                 ID HUDID
8898
8899                 Field HUDField
8900
8901                 //mt:if %s.Field == HUDPos
8902                 Pos [2]float32
8903
8904                 //mt:if %s.Field == HUDName
8905                 Name string
8906
8907                 //mt:if %s.Field == HUDScale
8908                 Scale [2]float32
8909
8910                 //mt:if %s.Field == HUDText
8911                 Text string
8912
8913                 //mt:if %s.Field == HUDNumber
8914                 Number uint32
8915
8916                 //mt:if %s.Field == HUDItem
8917                 Item uint32
8918
8919                 //mt:if %s.Field == HUDDir
8920                 Dir uint32
8921
8922                 //mt:if %s.Field == HUDAlign
8923                 Align [2]float32
8924
8925                 //mt:if %s.Field == HUDOffset
8926                 Offset [2]float32
8927
8928                 //mt:if %s.Field == HUDWorldPos
8929                 WorldPos Pos
8930
8931                 //mt:if %s.Field == HUDSize
8932                 Size [2]int32
8933
8934                 //mt:if %s.Field == HUDZIndex
8935                 ZIndex int32
8936
8937                 //mt:if %s.Field == HUDText2
8938                 Text2 string
8939         }))(obj)).Field == HUDZIndex {
8940                 {
8941                         x := (*(*(struct {
8942                                 ID HUDID
8943
8944                                 Field HUDField
8945
8946                                 //mt:if %s.Field == HUDPos
8947                                 Pos [2]float32
8948
8949                                 //mt:if %s.Field == HUDName
8950                                 Name string
8951
8952                                 //mt:if %s.Field == HUDScale
8953                                 Scale [2]float32
8954
8955                                 //mt:if %s.Field == HUDText
8956                                 Text string
8957
8958                                 //mt:if %s.Field == HUDNumber
8959                                 Number uint32
8960
8961                                 //mt:if %s.Field == HUDItem
8962                                 Item uint32
8963
8964                                 //mt:if %s.Field == HUDDir
8965                                 Dir uint32
8966
8967                                 //mt:if %s.Field == HUDAlign
8968                                 Align [2]float32
8969
8970                                 //mt:if %s.Field == HUDOffset
8971                                 Offset [2]float32
8972
8973                                 //mt:if %s.Field == HUDWorldPos
8974                                 WorldPos Pos
8975
8976                                 //mt:if %s.Field == HUDSize
8977                                 Size [2]int32
8978
8979                                 //mt:if %s.Field == HUDZIndex
8980                                 ZIndex int32
8981
8982                                 //mt:if %s.Field == HUDText2
8983                                 Text2 string
8984                         }))(obj)).ZIndex
8985                         write32(w, uint32(x))
8986                 }
8987         }
8988         if (*(*(struct {
8989                 ID HUDID
8990
8991                 Field HUDField
8992
8993                 //mt:if %s.Field == HUDPos
8994                 Pos [2]float32
8995
8996                 //mt:if %s.Field == HUDName
8997                 Name string
8998
8999                 //mt:if %s.Field == HUDScale
9000                 Scale [2]float32
9001
9002                 //mt:if %s.Field == HUDText
9003                 Text string
9004
9005                 //mt:if %s.Field == HUDNumber
9006                 Number uint32
9007
9008                 //mt:if %s.Field == HUDItem
9009                 Item uint32
9010
9011                 //mt:if %s.Field == HUDDir
9012                 Dir uint32
9013
9014                 //mt:if %s.Field == HUDAlign
9015                 Align [2]float32
9016
9017                 //mt:if %s.Field == HUDOffset
9018                 Offset [2]float32
9019
9020                 //mt:if %s.Field == HUDWorldPos
9021                 WorldPos Pos
9022
9023                 //mt:if %s.Field == HUDSize
9024                 Size [2]int32
9025
9026                 //mt:if %s.Field == HUDZIndex
9027                 ZIndex int32
9028
9029                 //mt:if %s.Field == HUDText2
9030                 Text2 string
9031         }))(obj)).Field == HUDText2 {
9032                 if len(([]byte((*(*(struct {
9033                         ID HUDID
9034
9035                         Field HUDField
9036
9037                         //mt:if %s.Field == HUDPos
9038                         Pos [2]float32
9039
9040                         //mt:if %s.Field == HUDName
9041                         Name string
9042
9043                         //mt:if %s.Field == HUDScale
9044                         Scale [2]float32
9045
9046                         //mt:if %s.Field == HUDText
9047                         Text string
9048
9049                         //mt:if %s.Field == HUDNumber
9050                         Number uint32
9051
9052                         //mt:if %s.Field == HUDItem
9053                         Item uint32
9054
9055                         //mt:if %s.Field == HUDDir
9056                         Dir uint32
9057
9058                         //mt:if %s.Field == HUDAlign
9059                         Align [2]float32
9060
9061                         //mt:if %s.Field == HUDOffset
9062                         Offset [2]float32
9063
9064                         //mt:if %s.Field == HUDWorldPos
9065                         WorldPos Pos
9066
9067                         //mt:if %s.Field == HUDSize
9068                         Size [2]int32
9069
9070                         //mt:if %s.Field == HUDZIndex
9071                         ZIndex int32
9072
9073                         //mt:if %s.Field == HUDText2
9074                         Text2 string
9075                 }))(obj)).Text2))) > math.MaxUint16 {
9076                         chk(ErrTooLong)
9077                 }
9078                 {
9079                         x := uint16(len(([]byte((*(*(struct {
9080                                 ID HUDID
9081
9082                                 Field HUDField
9083
9084                                 //mt:if %s.Field == HUDPos
9085                                 Pos [2]float32
9086
9087                                 //mt:if %s.Field == HUDName
9088                                 Name string
9089
9090                                 //mt:if %s.Field == HUDScale
9091                                 Scale [2]float32
9092
9093                                 //mt:if %s.Field == HUDText
9094                                 Text string
9095
9096                                 //mt:if %s.Field == HUDNumber
9097                                 Number uint32
9098
9099                                 //mt:if %s.Field == HUDItem
9100                                 Item uint32
9101
9102                                 //mt:if %s.Field == HUDDir
9103                                 Dir uint32
9104
9105                                 //mt:if %s.Field == HUDAlign
9106                                 Align [2]float32
9107
9108                                 //mt:if %s.Field == HUDOffset
9109                                 Offset [2]float32
9110
9111                                 //mt:if %s.Field == HUDWorldPos
9112                                 WorldPos Pos
9113
9114                                 //mt:if %s.Field == HUDSize
9115                                 Size [2]int32
9116
9117                                 //mt:if %s.Field == HUDZIndex
9118                                 ZIndex int32
9119
9120                                 //mt:if %s.Field == HUDText2
9121                                 Text2 string
9122                         }))(obj)).Text2))))
9123                         write16(w, uint16(x))
9124                 }
9125                 {
9126                         _, err := w.Write(([]byte((*(*(struct {
9127                                 ID HUDID
9128
9129                                 Field HUDField
9130
9131                                 //mt:if %s.Field == HUDPos
9132                                 Pos [2]float32
9133
9134                                 //mt:if %s.Field == HUDName
9135                                 Name string
9136
9137                                 //mt:if %s.Field == HUDScale
9138                                 Scale [2]float32
9139
9140                                 //mt:if %s.Field == HUDText
9141                                 Text string
9142
9143                                 //mt:if %s.Field == HUDNumber
9144                                 Number uint32
9145
9146                                 //mt:if %s.Field == HUDItem
9147                                 Item uint32
9148
9149                                 //mt:if %s.Field == HUDDir
9150                                 Dir uint32
9151
9152                                 //mt:if %s.Field == HUDAlign
9153                                 Align [2]float32
9154
9155                                 //mt:if %s.Field == HUDOffset
9156                                 Offset [2]float32
9157
9158                                 //mt:if %s.Field == HUDWorldPos
9159                                 WorldPos Pos
9160
9161                                 //mt:if %s.Field == HUDSize
9162                                 Size [2]int32
9163
9164                                 //mt:if %s.Field == HUDZIndex
9165                                 ZIndex int32
9166
9167                                 //mt:if %s.Field == HUDText2
9168                                 Text2 string
9169                         }))(obj)).Text2))[:])
9170                         chk(err)
9171                 }
9172         }
9173 }
9174
9175 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9176         if err := pcall(func() {
9177                 ((*(*(struct {
9178                         ID HUDID
9179
9180                         Field HUDField
9181
9182                         //mt:if %s.Field == HUDPos
9183                         Pos [2]float32
9184
9185                         //mt:if %s.Field == HUDName
9186                         Name string
9187
9188                         //mt:if %s.Field == HUDScale
9189                         Scale [2]float32
9190
9191                         //mt:if %s.Field == HUDText
9192                         Text string
9193
9194                         //mt:if %s.Field == HUDNumber
9195                         Number uint32
9196
9197                         //mt:if %s.Field == HUDItem
9198                         Item uint32
9199
9200                         //mt:if %s.Field == HUDDir
9201                         Dir uint32
9202
9203                         //mt:if %s.Field == HUDAlign
9204                         Align [2]float32
9205
9206                         //mt:if %s.Field == HUDOffset
9207                         Offset [2]float32
9208
9209                         //mt:if %s.Field == HUDWorldPos
9210                         WorldPos Pos
9211
9212                         //mt:if %s.Field == HUDSize
9213                         Size [2]int32
9214
9215                         //mt:if %s.Field == HUDZIndex
9216                         ZIndex int32
9217
9218                         //mt:if %s.Field == HUDText2
9219                         Text2 string
9220                 }))(obj)).ID).deserialize(r)
9221         }); err != nil {
9222                 if err == io.EOF {
9223                         chk(io.EOF)
9224                 }
9225                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDID", err))
9226         }
9227         if err := pcall(func() {
9228                 ((*(*(struct {
9229                         ID HUDID
9230
9231                         Field HUDField
9232
9233                         //mt:if %s.Field == HUDPos
9234                         Pos [2]float32
9235
9236                         //mt:if %s.Field == HUDName
9237                         Name string
9238
9239                         //mt:if %s.Field == HUDScale
9240                         Scale [2]float32
9241
9242                         //mt:if %s.Field == HUDText
9243                         Text string
9244
9245                         //mt:if %s.Field == HUDNumber
9246                         Number uint32
9247
9248                         //mt:if %s.Field == HUDItem
9249                         Item uint32
9250
9251                         //mt:if %s.Field == HUDDir
9252                         Dir uint32
9253
9254                         //mt:if %s.Field == HUDAlign
9255                         Align [2]float32
9256
9257                         //mt:if %s.Field == HUDOffset
9258                         Offset [2]float32
9259
9260                         //mt:if %s.Field == HUDWorldPos
9261                         WorldPos Pos
9262
9263                         //mt:if %s.Field == HUDSize
9264                         Size [2]int32
9265
9266                         //mt:if %s.Field == HUDZIndex
9267                         ZIndex int32
9268
9269                         //mt:if %s.Field == HUDText2
9270                         Text2 string
9271                 }))(obj)).Field).deserialize(r)
9272         }); err != nil {
9273                 if err == io.EOF {
9274                         chk(io.EOF)
9275                 }
9276                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDField", err))
9277         }
9278         if !((*(*(struct {
9279                 ID HUDID
9280
9281                 Field HUDField
9282
9283                 //mt:if %s.Field == HUDPos
9284                 Pos [2]float32
9285
9286                 //mt:if %s.Field == HUDName
9287                 Name string
9288
9289                 //mt:if %s.Field == HUDScale
9290                 Scale [2]float32
9291
9292                 //mt:if %s.Field == HUDText
9293                 Text string
9294
9295                 //mt:if %s.Field == HUDNumber
9296                 Number uint32
9297
9298                 //mt:if %s.Field == HUDItem
9299                 Item uint32
9300
9301                 //mt:if %s.Field == HUDDir
9302                 Dir uint32
9303
9304                 //mt:if %s.Field == HUDAlign
9305                 Align [2]float32
9306
9307                 //mt:if %s.Field == HUDOffset
9308                 Offset [2]float32
9309
9310                 //mt:if %s.Field == HUDWorldPos
9311                 WorldPos Pos
9312
9313                 //mt:if %s.Field == HUDSize
9314                 Size [2]int32
9315
9316                 //mt:if %s.Field == HUDZIndex
9317                 ZIndex int32
9318
9319                 //mt:if %s.Field == HUDText2
9320                 Text2 string
9321         }))(obj)).Field < hudMax) {
9322                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9323         }
9324         if (*(*(struct {
9325                 ID HUDID
9326
9327                 Field HUDField
9328
9329                 //mt:if %s.Field == HUDPos
9330                 Pos [2]float32
9331
9332                 //mt:if %s.Field == HUDName
9333                 Name string
9334
9335                 //mt:if %s.Field == HUDScale
9336                 Scale [2]float32
9337
9338                 //mt:if %s.Field == HUDText
9339                 Text string
9340
9341                 //mt:if %s.Field == HUDNumber
9342                 Number uint32
9343
9344                 //mt:if %s.Field == HUDItem
9345                 Item uint32
9346
9347                 //mt:if %s.Field == HUDDir
9348                 Dir uint32
9349
9350                 //mt:if %s.Field == HUDAlign
9351                 Align [2]float32
9352
9353                 //mt:if %s.Field == HUDOffset
9354                 Offset [2]float32
9355
9356                 //mt:if %s.Field == HUDWorldPos
9357                 WorldPos Pos
9358
9359                 //mt:if %s.Field == HUDSize
9360                 Size [2]int32
9361
9362                 //mt:if %s.Field == HUDZIndex
9363                 ZIndex int32
9364
9365                 //mt:if %s.Field == HUDText2
9366                 Text2 string
9367         }))(obj)).Field == HUDPos {
9368                 for local177 := range (*(*(struct {
9369                         ID HUDID
9370
9371                         Field HUDField
9372
9373                         //mt:if %s.Field == HUDPos
9374                         Pos [2]float32
9375
9376                         //mt:if %s.Field == HUDName
9377                         Name string
9378
9379                         //mt:if %s.Field == HUDScale
9380                         Scale [2]float32
9381
9382                         //mt:if %s.Field == HUDText
9383                         Text string
9384
9385                         //mt:if %s.Field == HUDNumber
9386                         Number uint32
9387
9388                         //mt:if %s.Field == HUDItem
9389                         Item uint32
9390
9391                         //mt:if %s.Field == HUDDir
9392                         Dir uint32
9393
9394                         //mt:if %s.Field == HUDAlign
9395                         Align [2]float32
9396
9397                         //mt:if %s.Field == HUDOffset
9398                         Offset [2]float32
9399
9400                         //mt:if %s.Field == HUDWorldPos
9401                         WorldPos Pos
9402
9403                         //mt:if %s.Field == HUDSize
9404                         Size [2]int32
9405
9406                         //mt:if %s.Field == HUDZIndex
9407                         ZIndex int32
9408
9409                         //mt:if %s.Field == HUDText2
9410                         Text2 string
9411                 }))(obj)).Pos {
9412                         {
9413                                 p := &((*(*(struct {
9414                                         ID HUDID
9415
9416                                         Field HUDField
9417
9418                                         //mt:if %s.Field == HUDPos
9419                                         Pos [2]float32
9420
9421                                         //mt:if %s.Field == HUDName
9422                                         Name string
9423
9424                                         //mt:if %s.Field == HUDScale
9425                                         Scale [2]float32
9426
9427                                         //mt:if %s.Field == HUDText
9428                                         Text string
9429
9430                                         //mt:if %s.Field == HUDNumber
9431                                         Number uint32
9432
9433                                         //mt:if %s.Field == HUDItem
9434                                         Item uint32
9435
9436                                         //mt:if %s.Field == HUDDir
9437                                         Dir uint32
9438
9439                                         //mt:if %s.Field == HUDAlign
9440                                         Align [2]float32
9441
9442                                         //mt:if %s.Field == HUDOffset
9443                                         Offset [2]float32
9444
9445                                         //mt:if %s.Field == HUDWorldPos
9446                                         WorldPos Pos
9447
9448                                         //mt:if %s.Field == HUDSize
9449                                         Size [2]int32
9450
9451                                         //mt:if %s.Field == HUDZIndex
9452                                         ZIndex int32
9453
9454                                         //mt:if %s.Field == HUDText2
9455                                         Text2 string
9456                                 }))(obj)).Pos)[local177]
9457                                 *p = math.Float32frombits(read32(r))
9458                         }
9459                 }
9460         }
9461         if (*(*(struct {
9462                 ID HUDID
9463
9464                 Field HUDField
9465
9466                 //mt:if %s.Field == HUDPos
9467                 Pos [2]float32
9468
9469                 //mt:if %s.Field == HUDName
9470                 Name string
9471
9472                 //mt:if %s.Field == HUDScale
9473                 Scale [2]float32
9474
9475                 //mt:if %s.Field == HUDText
9476                 Text string
9477
9478                 //mt:if %s.Field == HUDNumber
9479                 Number uint32
9480
9481                 //mt:if %s.Field == HUDItem
9482                 Item uint32
9483
9484                 //mt:if %s.Field == HUDDir
9485                 Dir uint32
9486
9487                 //mt:if %s.Field == HUDAlign
9488                 Align [2]float32
9489
9490                 //mt:if %s.Field == HUDOffset
9491                 Offset [2]float32
9492
9493                 //mt:if %s.Field == HUDWorldPos
9494                 WorldPos Pos
9495
9496                 //mt:if %s.Field == HUDSize
9497                 Size [2]int32
9498
9499                 //mt:if %s.Field == HUDZIndex
9500                 ZIndex int32
9501
9502                 //mt:if %s.Field == HUDText2
9503                 Text2 string
9504         }))(obj)).Field == HUDName {
9505                 var local178 []uint8
9506                 var local179 uint16
9507                 {
9508                         p := &local179
9509                         *p = read16(r)
9510                 }
9511                 (local178) = make([]uint8, local179)
9512                 {
9513                         _, err := io.ReadFull(r, (local178)[:])
9514                         chk(err)
9515                 }
9516                 ((*(*(struct {
9517                         ID HUDID
9518
9519                         Field HUDField
9520
9521                         //mt:if %s.Field == HUDPos
9522                         Pos [2]float32
9523
9524                         //mt:if %s.Field == HUDName
9525                         Name string
9526
9527                         //mt:if %s.Field == HUDScale
9528                         Scale [2]float32
9529
9530                         //mt:if %s.Field == HUDText
9531                         Text string
9532
9533                         //mt:if %s.Field == HUDNumber
9534                         Number uint32
9535
9536                         //mt:if %s.Field == HUDItem
9537                         Item uint32
9538
9539                         //mt:if %s.Field == HUDDir
9540                         Dir uint32
9541
9542                         //mt:if %s.Field == HUDAlign
9543                         Align [2]float32
9544
9545                         //mt:if %s.Field == HUDOffset
9546                         Offset [2]float32
9547
9548                         //mt:if %s.Field == HUDWorldPos
9549                         WorldPos Pos
9550
9551                         //mt:if %s.Field == HUDSize
9552                         Size [2]int32
9553
9554                         //mt:if %s.Field == HUDZIndex
9555                         ZIndex int32
9556
9557                         //mt:if %s.Field == HUDText2
9558                         Text2 string
9559                 }))(obj)).Name) = string(local178)
9560         }
9561         if (*(*(struct {
9562                 ID HUDID
9563
9564                 Field HUDField
9565
9566                 //mt:if %s.Field == HUDPos
9567                 Pos [2]float32
9568
9569                 //mt:if %s.Field == HUDName
9570                 Name string
9571
9572                 //mt:if %s.Field == HUDScale
9573                 Scale [2]float32
9574
9575                 //mt:if %s.Field == HUDText
9576                 Text string
9577
9578                 //mt:if %s.Field == HUDNumber
9579                 Number uint32
9580
9581                 //mt:if %s.Field == HUDItem
9582                 Item uint32
9583
9584                 //mt:if %s.Field == HUDDir
9585                 Dir uint32
9586
9587                 //mt:if %s.Field == HUDAlign
9588                 Align [2]float32
9589
9590                 //mt:if %s.Field == HUDOffset
9591                 Offset [2]float32
9592
9593                 //mt:if %s.Field == HUDWorldPos
9594                 WorldPos Pos
9595
9596                 //mt:if %s.Field == HUDSize
9597                 Size [2]int32
9598
9599                 //mt:if %s.Field == HUDZIndex
9600                 ZIndex int32
9601
9602                 //mt:if %s.Field == HUDText2
9603                 Text2 string
9604         }))(obj)).Field == HUDScale {
9605                 for local180 := range (*(*(struct {
9606                         ID HUDID
9607
9608                         Field HUDField
9609
9610                         //mt:if %s.Field == HUDPos
9611                         Pos [2]float32
9612
9613                         //mt:if %s.Field == HUDName
9614                         Name string
9615
9616                         //mt:if %s.Field == HUDScale
9617                         Scale [2]float32
9618
9619                         //mt:if %s.Field == HUDText
9620                         Text string
9621
9622                         //mt:if %s.Field == HUDNumber
9623                         Number uint32
9624
9625                         //mt:if %s.Field == HUDItem
9626                         Item uint32
9627
9628                         //mt:if %s.Field == HUDDir
9629                         Dir uint32
9630
9631                         //mt:if %s.Field == HUDAlign
9632                         Align [2]float32
9633
9634                         //mt:if %s.Field == HUDOffset
9635                         Offset [2]float32
9636
9637                         //mt:if %s.Field == HUDWorldPos
9638                         WorldPos Pos
9639
9640                         //mt:if %s.Field == HUDSize
9641                         Size [2]int32
9642
9643                         //mt:if %s.Field == HUDZIndex
9644                         ZIndex int32
9645
9646                         //mt:if %s.Field == HUDText2
9647                         Text2 string
9648                 }))(obj)).Scale {
9649                         {
9650                                 p := &((*(*(struct {
9651                                         ID HUDID
9652
9653                                         Field HUDField
9654
9655                                         //mt:if %s.Field == HUDPos
9656                                         Pos [2]float32
9657
9658                                         //mt:if %s.Field == HUDName
9659                                         Name string
9660
9661                                         //mt:if %s.Field == HUDScale
9662                                         Scale [2]float32
9663
9664                                         //mt:if %s.Field == HUDText
9665                                         Text string
9666
9667                                         //mt:if %s.Field == HUDNumber
9668                                         Number uint32
9669
9670                                         //mt:if %s.Field == HUDItem
9671                                         Item uint32
9672
9673                                         //mt:if %s.Field == HUDDir
9674                                         Dir uint32
9675
9676                                         //mt:if %s.Field == HUDAlign
9677                                         Align [2]float32
9678
9679                                         //mt:if %s.Field == HUDOffset
9680                                         Offset [2]float32
9681
9682                                         //mt:if %s.Field == HUDWorldPos
9683                                         WorldPos Pos
9684
9685                                         //mt:if %s.Field == HUDSize
9686                                         Size [2]int32
9687
9688                                         //mt:if %s.Field == HUDZIndex
9689                                         ZIndex int32
9690
9691                                         //mt:if %s.Field == HUDText2
9692                                         Text2 string
9693                                 }))(obj)).Scale)[local180]
9694                                 *p = math.Float32frombits(read32(r))
9695                         }
9696                 }
9697         }
9698         if (*(*(struct {
9699                 ID HUDID
9700
9701                 Field HUDField
9702
9703                 //mt:if %s.Field == HUDPos
9704                 Pos [2]float32
9705
9706                 //mt:if %s.Field == HUDName
9707                 Name string
9708
9709                 //mt:if %s.Field == HUDScale
9710                 Scale [2]float32
9711
9712                 //mt:if %s.Field == HUDText
9713                 Text string
9714
9715                 //mt:if %s.Field == HUDNumber
9716                 Number uint32
9717
9718                 //mt:if %s.Field == HUDItem
9719                 Item uint32
9720
9721                 //mt:if %s.Field == HUDDir
9722                 Dir uint32
9723
9724                 //mt:if %s.Field == HUDAlign
9725                 Align [2]float32
9726
9727                 //mt:if %s.Field == HUDOffset
9728                 Offset [2]float32
9729
9730                 //mt:if %s.Field == HUDWorldPos
9731                 WorldPos Pos
9732
9733                 //mt:if %s.Field == HUDSize
9734                 Size [2]int32
9735
9736                 //mt:if %s.Field == HUDZIndex
9737                 ZIndex int32
9738
9739                 //mt:if %s.Field == HUDText2
9740                 Text2 string
9741         }))(obj)).Field == HUDText {
9742                 var local181 []uint8
9743                 var local182 uint16
9744                 {
9745                         p := &local182
9746                         *p = read16(r)
9747                 }
9748                 (local181) = make([]uint8, local182)
9749                 {
9750                         _, err := io.ReadFull(r, (local181)[:])
9751                         chk(err)
9752                 }
9753                 ((*(*(struct {
9754                         ID HUDID
9755
9756                         Field HUDField
9757
9758                         //mt:if %s.Field == HUDPos
9759                         Pos [2]float32
9760
9761                         //mt:if %s.Field == HUDName
9762                         Name string
9763
9764                         //mt:if %s.Field == HUDScale
9765                         Scale [2]float32
9766
9767                         //mt:if %s.Field == HUDText
9768                         Text string
9769
9770                         //mt:if %s.Field == HUDNumber
9771                         Number uint32
9772
9773                         //mt:if %s.Field == HUDItem
9774                         Item uint32
9775
9776                         //mt:if %s.Field == HUDDir
9777                         Dir uint32
9778
9779                         //mt:if %s.Field == HUDAlign
9780                         Align [2]float32
9781
9782                         //mt:if %s.Field == HUDOffset
9783                         Offset [2]float32
9784
9785                         //mt:if %s.Field == HUDWorldPos
9786                         WorldPos Pos
9787
9788                         //mt:if %s.Field == HUDSize
9789                         Size [2]int32
9790
9791                         //mt:if %s.Field == HUDZIndex
9792                         ZIndex int32
9793
9794                         //mt:if %s.Field == HUDText2
9795                         Text2 string
9796                 }))(obj)).Text) = string(local181)
9797         }
9798         if (*(*(struct {
9799                 ID HUDID
9800
9801                 Field HUDField
9802
9803                 //mt:if %s.Field == HUDPos
9804                 Pos [2]float32
9805
9806                 //mt:if %s.Field == HUDName
9807                 Name string
9808
9809                 //mt:if %s.Field == HUDScale
9810                 Scale [2]float32
9811
9812                 //mt:if %s.Field == HUDText
9813                 Text string
9814
9815                 //mt:if %s.Field == HUDNumber
9816                 Number uint32
9817
9818                 //mt:if %s.Field == HUDItem
9819                 Item uint32
9820
9821                 //mt:if %s.Field == HUDDir
9822                 Dir uint32
9823
9824                 //mt:if %s.Field == HUDAlign
9825                 Align [2]float32
9826
9827                 //mt:if %s.Field == HUDOffset
9828                 Offset [2]float32
9829
9830                 //mt:if %s.Field == HUDWorldPos
9831                 WorldPos Pos
9832
9833                 //mt:if %s.Field == HUDSize
9834                 Size [2]int32
9835
9836                 //mt:if %s.Field == HUDZIndex
9837                 ZIndex int32
9838
9839                 //mt:if %s.Field == HUDText2
9840                 Text2 string
9841         }))(obj)).Field == HUDNumber {
9842                 {
9843                         p := &(*(*(struct {
9844                                 ID HUDID
9845
9846                                 Field HUDField
9847
9848                                 //mt:if %s.Field == HUDPos
9849                                 Pos [2]float32
9850
9851                                 //mt:if %s.Field == HUDName
9852                                 Name string
9853
9854                                 //mt:if %s.Field == HUDScale
9855                                 Scale [2]float32
9856
9857                                 //mt:if %s.Field == HUDText
9858                                 Text string
9859
9860                                 //mt:if %s.Field == HUDNumber
9861                                 Number uint32
9862
9863                                 //mt:if %s.Field == HUDItem
9864                                 Item uint32
9865
9866                                 //mt:if %s.Field == HUDDir
9867                                 Dir uint32
9868
9869                                 //mt:if %s.Field == HUDAlign
9870                                 Align [2]float32
9871
9872                                 //mt:if %s.Field == HUDOffset
9873                                 Offset [2]float32
9874
9875                                 //mt:if %s.Field == HUDWorldPos
9876                                 WorldPos Pos
9877
9878                                 //mt:if %s.Field == HUDSize
9879                                 Size [2]int32
9880
9881                                 //mt:if %s.Field == HUDZIndex
9882                                 ZIndex int32
9883
9884                                 //mt:if %s.Field == HUDText2
9885                                 Text2 string
9886                         }))(obj)).Number
9887                         *p = read32(r)
9888                 }
9889         }
9890         if (*(*(struct {
9891                 ID HUDID
9892
9893                 Field HUDField
9894
9895                 //mt:if %s.Field == HUDPos
9896                 Pos [2]float32
9897
9898                 //mt:if %s.Field == HUDName
9899                 Name string
9900
9901                 //mt:if %s.Field == HUDScale
9902                 Scale [2]float32
9903
9904                 //mt:if %s.Field == HUDText
9905                 Text string
9906
9907                 //mt:if %s.Field == HUDNumber
9908                 Number uint32
9909
9910                 //mt:if %s.Field == HUDItem
9911                 Item uint32
9912
9913                 //mt:if %s.Field == HUDDir
9914                 Dir uint32
9915
9916                 //mt:if %s.Field == HUDAlign
9917                 Align [2]float32
9918
9919                 //mt:if %s.Field == HUDOffset
9920                 Offset [2]float32
9921
9922                 //mt:if %s.Field == HUDWorldPos
9923                 WorldPos Pos
9924
9925                 //mt:if %s.Field == HUDSize
9926                 Size [2]int32
9927
9928                 //mt:if %s.Field == HUDZIndex
9929                 ZIndex int32
9930
9931                 //mt:if %s.Field == HUDText2
9932                 Text2 string
9933         }))(obj)).Field == HUDItem {
9934                 {
9935                         p := &(*(*(struct {
9936                                 ID HUDID
9937
9938                                 Field HUDField
9939
9940                                 //mt:if %s.Field == HUDPos
9941                                 Pos [2]float32
9942
9943                                 //mt:if %s.Field == HUDName
9944                                 Name string
9945
9946                                 //mt:if %s.Field == HUDScale
9947                                 Scale [2]float32
9948
9949                                 //mt:if %s.Field == HUDText
9950                                 Text string
9951
9952                                 //mt:if %s.Field == HUDNumber
9953                                 Number uint32
9954
9955                                 //mt:if %s.Field == HUDItem
9956                                 Item uint32
9957
9958                                 //mt:if %s.Field == HUDDir
9959                                 Dir uint32
9960
9961                                 //mt:if %s.Field == HUDAlign
9962                                 Align [2]float32
9963
9964                                 //mt:if %s.Field == HUDOffset
9965                                 Offset [2]float32
9966
9967                                 //mt:if %s.Field == HUDWorldPos
9968                                 WorldPos Pos
9969
9970                                 //mt:if %s.Field == HUDSize
9971                                 Size [2]int32
9972
9973                                 //mt:if %s.Field == HUDZIndex
9974                                 ZIndex int32
9975
9976                                 //mt:if %s.Field == HUDText2
9977                                 Text2 string
9978                         }))(obj)).Item
9979                         *p = read32(r)
9980                 }
9981         }
9982         if (*(*(struct {
9983                 ID HUDID
9984
9985                 Field HUDField
9986
9987                 //mt:if %s.Field == HUDPos
9988                 Pos [2]float32
9989
9990                 //mt:if %s.Field == HUDName
9991                 Name string
9992
9993                 //mt:if %s.Field == HUDScale
9994                 Scale [2]float32
9995
9996                 //mt:if %s.Field == HUDText
9997                 Text string
9998
9999                 //mt:if %s.Field == HUDNumber
10000                 Number uint32
10001
10002                 //mt:if %s.Field == HUDItem
10003                 Item uint32
10004
10005                 //mt:if %s.Field == HUDDir
10006                 Dir uint32
10007
10008                 //mt:if %s.Field == HUDAlign
10009                 Align [2]float32
10010
10011                 //mt:if %s.Field == HUDOffset
10012                 Offset [2]float32
10013
10014                 //mt:if %s.Field == HUDWorldPos
10015                 WorldPos Pos
10016
10017                 //mt:if %s.Field == HUDSize
10018                 Size [2]int32
10019
10020                 //mt:if %s.Field == HUDZIndex
10021                 ZIndex int32
10022
10023                 //mt:if %s.Field == HUDText2
10024                 Text2 string
10025         }))(obj)).Field == HUDDir {
10026                 {
10027                         p := &(*(*(struct {
10028                                 ID HUDID
10029
10030                                 Field HUDField
10031
10032                                 //mt:if %s.Field == HUDPos
10033                                 Pos [2]float32
10034
10035                                 //mt:if %s.Field == HUDName
10036                                 Name string
10037
10038                                 //mt:if %s.Field == HUDScale
10039                                 Scale [2]float32
10040
10041                                 //mt:if %s.Field == HUDText
10042                                 Text string
10043
10044                                 //mt:if %s.Field == HUDNumber
10045                                 Number uint32
10046
10047                                 //mt:if %s.Field == HUDItem
10048                                 Item uint32
10049
10050                                 //mt:if %s.Field == HUDDir
10051                                 Dir uint32
10052
10053                                 //mt:if %s.Field == HUDAlign
10054                                 Align [2]float32
10055
10056                                 //mt:if %s.Field == HUDOffset
10057                                 Offset [2]float32
10058
10059                                 //mt:if %s.Field == HUDWorldPos
10060                                 WorldPos Pos
10061
10062                                 //mt:if %s.Field == HUDSize
10063                                 Size [2]int32
10064
10065                                 //mt:if %s.Field == HUDZIndex
10066                                 ZIndex int32
10067
10068                                 //mt:if %s.Field == HUDText2
10069                                 Text2 string
10070                         }))(obj)).Dir
10071                         *p = read32(r)
10072                 }
10073         }
10074         if (*(*(struct {
10075                 ID HUDID
10076
10077                 Field HUDField
10078
10079                 //mt:if %s.Field == HUDPos
10080                 Pos [2]float32
10081
10082                 //mt:if %s.Field == HUDName
10083                 Name string
10084
10085                 //mt:if %s.Field == HUDScale
10086                 Scale [2]float32
10087
10088                 //mt:if %s.Field == HUDText
10089                 Text string
10090
10091                 //mt:if %s.Field == HUDNumber
10092                 Number uint32
10093
10094                 //mt:if %s.Field == HUDItem
10095                 Item uint32
10096
10097                 //mt:if %s.Field == HUDDir
10098                 Dir uint32
10099
10100                 //mt:if %s.Field == HUDAlign
10101                 Align [2]float32
10102
10103                 //mt:if %s.Field == HUDOffset
10104                 Offset [2]float32
10105
10106                 //mt:if %s.Field == HUDWorldPos
10107                 WorldPos Pos
10108
10109                 //mt:if %s.Field == HUDSize
10110                 Size [2]int32
10111
10112                 //mt:if %s.Field == HUDZIndex
10113                 ZIndex int32
10114
10115                 //mt:if %s.Field == HUDText2
10116                 Text2 string
10117         }))(obj)).Field == HUDAlign {
10118                 for local183 := range (*(*(struct {
10119                         ID HUDID
10120
10121                         Field HUDField
10122
10123                         //mt:if %s.Field == HUDPos
10124                         Pos [2]float32
10125
10126                         //mt:if %s.Field == HUDName
10127                         Name string
10128
10129                         //mt:if %s.Field == HUDScale
10130                         Scale [2]float32
10131
10132                         //mt:if %s.Field == HUDText
10133                         Text string
10134
10135                         //mt:if %s.Field == HUDNumber
10136                         Number uint32
10137
10138                         //mt:if %s.Field == HUDItem
10139                         Item uint32
10140
10141                         //mt:if %s.Field == HUDDir
10142                         Dir uint32
10143
10144                         //mt:if %s.Field == HUDAlign
10145                         Align [2]float32
10146
10147                         //mt:if %s.Field == HUDOffset
10148                         Offset [2]float32
10149
10150                         //mt:if %s.Field == HUDWorldPos
10151                         WorldPos Pos
10152
10153                         //mt:if %s.Field == HUDSize
10154                         Size [2]int32
10155
10156                         //mt:if %s.Field == HUDZIndex
10157                         ZIndex int32
10158
10159                         //mt:if %s.Field == HUDText2
10160                         Text2 string
10161                 }))(obj)).Align {
10162                         {
10163                                 p := &((*(*(struct {
10164                                         ID HUDID
10165
10166                                         Field HUDField
10167
10168                                         //mt:if %s.Field == HUDPos
10169                                         Pos [2]float32
10170
10171                                         //mt:if %s.Field == HUDName
10172                                         Name string
10173
10174                                         //mt:if %s.Field == HUDScale
10175                                         Scale [2]float32
10176
10177                                         //mt:if %s.Field == HUDText
10178                                         Text string
10179
10180                                         //mt:if %s.Field == HUDNumber
10181                                         Number uint32
10182
10183                                         //mt:if %s.Field == HUDItem
10184                                         Item uint32
10185
10186                                         //mt:if %s.Field == HUDDir
10187                                         Dir uint32
10188
10189                                         //mt:if %s.Field == HUDAlign
10190                                         Align [2]float32
10191
10192                                         //mt:if %s.Field == HUDOffset
10193                                         Offset [2]float32
10194
10195                                         //mt:if %s.Field == HUDWorldPos
10196                                         WorldPos Pos
10197
10198                                         //mt:if %s.Field == HUDSize
10199                                         Size [2]int32
10200
10201                                         //mt:if %s.Field == HUDZIndex
10202                                         ZIndex int32
10203
10204                                         //mt:if %s.Field == HUDText2
10205                                         Text2 string
10206                                 }))(obj)).Align)[local183]
10207                                 *p = math.Float32frombits(read32(r))
10208                         }
10209                 }
10210         }
10211         if (*(*(struct {
10212                 ID HUDID
10213
10214                 Field HUDField
10215
10216                 //mt:if %s.Field == HUDPos
10217                 Pos [2]float32
10218
10219                 //mt:if %s.Field == HUDName
10220                 Name string
10221
10222                 //mt:if %s.Field == HUDScale
10223                 Scale [2]float32
10224
10225                 //mt:if %s.Field == HUDText
10226                 Text string
10227
10228                 //mt:if %s.Field == HUDNumber
10229                 Number uint32
10230
10231                 //mt:if %s.Field == HUDItem
10232                 Item uint32
10233
10234                 //mt:if %s.Field == HUDDir
10235                 Dir uint32
10236
10237                 //mt:if %s.Field == HUDAlign
10238                 Align [2]float32
10239
10240                 //mt:if %s.Field == HUDOffset
10241                 Offset [2]float32
10242
10243                 //mt:if %s.Field == HUDWorldPos
10244                 WorldPos Pos
10245
10246                 //mt:if %s.Field == HUDSize
10247                 Size [2]int32
10248
10249                 //mt:if %s.Field == HUDZIndex
10250                 ZIndex int32
10251
10252                 //mt:if %s.Field == HUDText2
10253                 Text2 string
10254         }))(obj)).Field == HUDOffset {
10255                 for local184 := range (*(*(struct {
10256                         ID HUDID
10257
10258                         Field HUDField
10259
10260                         //mt:if %s.Field == HUDPos
10261                         Pos [2]float32
10262
10263                         //mt:if %s.Field == HUDName
10264                         Name string
10265
10266                         //mt:if %s.Field == HUDScale
10267                         Scale [2]float32
10268
10269                         //mt:if %s.Field == HUDText
10270                         Text string
10271
10272                         //mt:if %s.Field == HUDNumber
10273                         Number uint32
10274
10275                         //mt:if %s.Field == HUDItem
10276                         Item uint32
10277
10278                         //mt:if %s.Field == HUDDir
10279                         Dir uint32
10280
10281                         //mt:if %s.Field == HUDAlign
10282                         Align [2]float32
10283
10284                         //mt:if %s.Field == HUDOffset
10285                         Offset [2]float32
10286
10287                         //mt:if %s.Field == HUDWorldPos
10288                         WorldPos Pos
10289
10290                         //mt:if %s.Field == HUDSize
10291                         Size [2]int32
10292
10293                         //mt:if %s.Field == HUDZIndex
10294                         ZIndex int32
10295
10296                         //mt:if %s.Field == HUDText2
10297                         Text2 string
10298                 }))(obj)).Offset {
10299                         {
10300                                 p := &((*(*(struct {
10301                                         ID HUDID
10302
10303                                         Field HUDField
10304
10305                                         //mt:if %s.Field == HUDPos
10306                                         Pos [2]float32
10307
10308                                         //mt:if %s.Field == HUDName
10309                                         Name string
10310
10311                                         //mt:if %s.Field == HUDScale
10312                                         Scale [2]float32
10313
10314                                         //mt:if %s.Field == HUDText
10315                                         Text string
10316
10317                                         //mt:if %s.Field == HUDNumber
10318                                         Number uint32
10319
10320                                         //mt:if %s.Field == HUDItem
10321                                         Item uint32
10322
10323                                         //mt:if %s.Field == HUDDir
10324                                         Dir uint32
10325
10326                                         //mt:if %s.Field == HUDAlign
10327                                         Align [2]float32
10328
10329                                         //mt:if %s.Field == HUDOffset
10330                                         Offset [2]float32
10331
10332                                         //mt:if %s.Field == HUDWorldPos
10333                                         WorldPos Pos
10334
10335                                         //mt:if %s.Field == HUDSize
10336                                         Size [2]int32
10337
10338                                         //mt:if %s.Field == HUDZIndex
10339                                         ZIndex int32
10340
10341                                         //mt:if %s.Field == HUDText2
10342                                         Text2 string
10343                                 }))(obj)).Offset)[local184]
10344                                 *p = math.Float32frombits(read32(r))
10345                         }
10346                 }
10347         }
10348         if (*(*(struct {
10349                 ID HUDID
10350
10351                 Field HUDField
10352
10353                 //mt:if %s.Field == HUDPos
10354                 Pos [2]float32
10355
10356                 //mt:if %s.Field == HUDName
10357                 Name string
10358
10359                 //mt:if %s.Field == HUDScale
10360                 Scale [2]float32
10361
10362                 //mt:if %s.Field == HUDText
10363                 Text string
10364
10365                 //mt:if %s.Field == HUDNumber
10366                 Number uint32
10367
10368                 //mt:if %s.Field == HUDItem
10369                 Item uint32
10370
10371                 //mt:if %s.Field == HUDDir
10372                 Dir uint32
10373
10374                 //mt:if %s.Field == HUDAlign
10375                 Align [2]float32
10376
10377                 //mt:if %s.Field == HUDOffset
10378                 Offset [2]float32
10379
10380                 //mt:if %s.Field == HUDWorldPos
10381                 WorldPos Pos
10382
10383                 //mt:if %s.Field == HUDSize
10384                 Size [2]int32
10385
10386                 //mt:if %s.Field == HUDZIndex
10387                 ZIndex int32
10388
10389                 //mt:if %s.Field == HUDText2
10390                 Text2 string
10391         }))(obj)).Field == HUDWorldPos {
10392                 if err := pcall(func() {
10393                         ((*(*(struct {
10394                                 ID HUDID
10395
10396                                 Field HUDField
10397
10398                                 //mt:if %s.Field == HUDPos
10399                                 Pos [2]float32
10400
10401                                 //mt:if %s.Field == HUDName
10402                                 Name string
10403
10404                                 //mt:if %s.Field == HUDScale
10405                                 Scale [2]float32
10406
10407                                 //mt:if %s.Field == HUDText
10408                                 Text string
10409
10410                                 //mt:if %s.Field == HUDNumber
10411                                 Number uint32
10412
10413                                 //mt:if %s.Field == HUDItem
10414                                 Item uint32
10415
10416                                 //mt:if %s.Field == HUDDir
10417                                 Dir uint32
10418
10419                                 //mt:if %s.Field == HUDAlign
10420                                 Align [2]float32
10421
10422                                 //mt:if %s.Field == HUDOffset
10423                                 Offset [2]float32
10424
10425                                 //mt:if %s.Field == HUDWorldPos
10426                                 WorldPos Pos
10427
10428                                 //mt:if %s.Field == HUDSize
10429                                 Size [2]int32
10430
10431                                 //mt:if %s.Field == HUDZIndex
10432                                 ZIndex int32
10433
10434                                 //mt:if %s.Field == HUDText2
10435                                 Text2 string
10436                         }))(obj)).WorldPos).deserialize(r)
10437                 }); err != nil {
10438                         if err == io.EOF {
10439                                 chk(io.EOF)
10440                         }
10441                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
10442                 }
10443         }
10444         if (*(*(struct {
10445                 ID HUDID
10446
10447                 Field HUDField
10448
10449                 //mt:if %s.Field == HUDPos
10450                 Pos [2]float32
10451
10452                 //mt:if %s.Field == HUDName
10453                 Name string
10454
10455                 //mt:if %s.Field == HUDScale
10456                 Scale [2]float32
10457
10458                 //mt:if %s.Field == HUDText
10459                 Text string
10460
10461                 //mt:if %s.Field == HUDNumber
10462                 Number uint32
10463
10464                 //mt:if %s.Field == HUDItem
10465                 Item uint32
10466
10467                 //mt:if %s.Field == HUDDir
10468                 Dir uint32
10469
10470                 //mt:if %s.Field == HUDAlign
10471                 Align [2]float32
10472
10473                 //mt:if %s.Field == HUDOffset
10474                 Offset [2]float32
10475
10476                 //mt:if %s.Field == HUDWorldPos
10477                 WorldPos Pos
10478
10479                 //mt:if %s.Field == HUDSize
10480                 Size [2]int32
10481
10482                 //mt:if %s.Field == HUDZIndex
10483                 ZIndex int32
10484
10485                 //mt:if %s.Field == HUDText2
10486                 Text2 string
10487         }))(obj)).Field == HUDSize {
10488                 for local185 := range (*(*(struct {
10489                         ID HUDID
10490
10491                         Field HUDField
10492
10493                         //mt:if %s.Field == HUDPos
10494                         Pos [2]float32
10495
10496                         //mt:if %s.Field == HUDName
10497                         Name string
10498
10499                         //mt:if %s.Field == HUDScale
10500                         Scale [2]float32
10501
10502                         //mt:if %s.Field == HUDText
10503                         Text string
10504
10505                         //mt:if %s.Field == HUDNumber
10506                         Number uint32
10507
10508                         //mt:if %s.Field == HUDItem
10509                         Item uint32
10510
10511                         //mt:if %s.Field == HUDDir
10512                         Dir uint32
10513
10514                         //mt:if %s.Field == HUDAlign
10515                         Align [2]float32
10516
10517                         //mt:if %s.Field == HUDOffset
10518                         Offset [2]float32
10519
10520                         //mt:if %s.Field == HUDWorldPos
10521                         WorldPos Pos
10522
10523                         //mt:if %s.Field == HUDSize
10524                         Size [2]int32
10525
10526                         //mt:if %s.Field == HUDZIndex
10527                         ZIndex int32
10528
10529                         //mt:if %s.Field == HUDText2
10530                         Text2 string
10531                 }))(obj)).Size {
10532                         {
10533                                 p := &((*(*(struct {
10534                                         ID HUDID
10535
10536                                         Field HUDField
10537
10538                                         //mt:if %s.Field == HUDPos
10539                                         Pos [2]float32
10540
10541                                         //mt:if %s.Field == HUDName
10542                                         Name string
10543
10544                                         //mt:if %s.Field == HUDScale
10545                                         Scale [2]float32
10546
10547                                         //mt:if %s.Field == HUDText
10548                                         Text string
10549
10550                                         //mt:if %s.Field == HUDNumber
10551                                         Number uint32
10552
10553                                         //mt:if %s.Field == HUDItem
10554                                         Item uint32
10555
10556                                         //mt:if %s.Field == HUDDir
10557                                         Dir uint32
10558
10559                                         //mt:if %s.Field == HUDAlign
10560                                         Align [2]float32
10561
10562                                         //mt:if %s.Field == HUDOffset
10563                                         Offset [2]float32
10564
10565                                         //mt:if %s.Field == HUDWorldPos
10566                                         WorldPos Pos
10567
10568                                         //mt:if %s.Field == HUDSize
10569                                         Size [2]int32
10570
10571                                         //mt:if %s.Field == HUDZIndex
10572                                         ZIndex int32
10573
10574                                         //mt:if %s.Field == HUDText2
10575                                         Text2 string
10576                                 }))(obj)).Size)[local185]
10577                                 *p = int32(read32(r))
10578                         }
10579                 }
10580         }
10581         if (*(*(struct {
10582                 ID HUDID
10583
10584                 Field HUDField
10585
10586                 //mt:if %s.Field == HUDPos
10587                 Pos [2]float32
10588
10589                 //mt:if %s.Field == HUDName
10590                 Name string
10591
10592                 //mt:if %s.Field == HUDScale
10593                 Scale [2]float32
10594
10595                 //mt:if %s.Field == HUDText
10596                 Text string
10597
10598                 //mt:if %s.Field == HUDNumber
10599                 Number uint32
10600
10601                 //mt:if %s.Field == HUDItem
10602                 Item uint32
10603
10604                 //mt:if %s.Field == HUDDir
10605                 Dir uint32
10606
10607                 //mt:if %s.Field == HUDAlign
10608                 Align [2]float32
10609
10610                 //mt:if %s.Field == HUDOffset
10611                 Offset [2]float32
10612
10613                 //mt:if %s.Field == HUDWorldPos
10614                 WorldPos Pos
10615
10616                 //mt:if %s.Field == HUDSize
10617                 Size [2]int32
10618
10619                 //mt:if %s.Field == HUDZIndex
10620                 ZIndex int32
10621
10622                 //mt:if %s.Field == HUDText2
10623                 Text2 string
10624         }))(obj)).Field == HUDZIndex {
10625                 {
10626                         p := &(*(*(struct {
10627                                 ID HUDID
10628
10629                                 Field HUDField
10630
10631                                 //mt:if %s.Field == HUDPos
10632                                 Pos [2]float32
10633
10634                                 //mt:if %s.Field == HUDName
10635                                 Name string
10636
10637                                 //mt:if %s.Field == HUDScale
10638                                 Scale [2]float32
10639
10640                                 //mt:if %s.Field == HUDText
10641                                 Text string
10642
10643                                 //mt:if %s.Field == HUDNumber
10644                                 Number uint32
10645
10646                                 //mt:if %s.Field == HUDItem
10647                                 Item uint32
10648
10649                                 //mt:if %s.Field == HUDDir
10650                                 Dir uint32
10651
10652                                 //mt:if %s.Field == HUDAlign
10653                                 Align [2]float32
10654
10655                                 //mt:if %s.Field == HUDOffset
10656                                 Offset [2]float32
10657
10658                                 //mt:if %s.Field == HUDWorldPos
10659                                 WorldPos Pos
10660
10661                                 //mt:if %s.Field == HUDSize
10662                                 Size [2]int32
10663
10664                                 //mt:if %s.Field == HUDZIndex
10665                                 ZIndex int32
10666
10667                                 //mt:if %s.Field == HUDText2
10668                                 Text2 string
10669                         }))(obj)).ZIndex
10670                         *p = int32(read32(r))
10671                 }
10672         }
10673         if (*(*(struct {
10674                 ID HUDID
10675
10676                 Field HUDField
10677
10678                 //mt:if %s.Field == HUDPos
10679                 Pos [2]float32
10680
10681                 //mt:if %s.Field == HUDName
10682                 Name string
10683
10684                 //mt:if %s.Field == HUDScale
10685                 Scale [2]float32
10686
10687                 //mt:if %s.Field == HUDText
10688                 Text string
10689
10690                 //mt:if %s.Field == HUDNumber
10691                 Number uint32
10692
10693                 //mt:if %s.Field == HUDItem
10694                 Item uint32
10695
10696                 //mt:if %s.Field == HUDDir
10697                 Dir uint32
10698
10699                 //mt:if %s.Field == HUDAlign
10700                 Align [2]float32
10701
10702                 //mt:if %s.Field == HUDOffset
10703                 Offset [2]float32
10704
10705                 //mt:if %s.Field == HUDWorldPos
10706                 WorldPos Pos
10707
10708                 //mt:if %s.Field == HUDSize
10709                 Size [2]int32
10710
10711                 //mt:if %s.Field == HUDZIndex
10712                 ZIndex int32
10713
10714                 //mt:if %s.Field == HUDText2
10715                 Text2 string
10716         }))(obj)).Field == HUDText2 {
10717                 var local186 []uint8
10718                 var local187 uint16
10719                 {
10720                         p := &local187
10721                         *p = read16(r)
10722                 }
10723                 (local186) = make([]uint8, local187)
10724                 {
10725                         _, err := io.ReadFull(r, (local186)[:])
10726                         chk(err)
10727                 }
10728                 ((*(*(struct {
10729                         ID HUDID
10730
10731                         Field HUDField
10732
10733                         //mt:if %s.Field == HUDPos
10734                         Pos [2]float32
10735
10736                         //mt:if %s.Field == HUDName
10737                         Name string
10738
10739                         //mt:if %s.Field == HUDScale
10740                         Scale [2]float32
10741
10742                         //mt:if %s.Field == HUDText
10743                         Text string
10744
10745                         //mt:if %s.Field == HUDNumber
10746                         Number uint32
10747
10748                         //mt:if %s.Field == HUDItem
10749                         Item uint32
10750
10751                         //mt:if %s.Field == HUDDir
10752                         Dir uint32
10753
10754                         //mt:if %s.Field == HUDAlign
10755                         Align [2]float32
10756
10757                         //mt:if %s.Field == HUDOffset
10758                         Offset [2]float32
10759
10760                         //mt:if %s.Field == HUDWorldPos
10761                         WorldPos Pos
10762
10763                         //mt:if %s.Field == HUDSize
10764                         Size [2]int32
10765
10766                         //mt:if %s.Field == HUDZIndex
10767                         ZIndex int32
10768
10769                         //mt:if %s.Field == HUDText2
10770                         Text2 string
10771                 }))(obj)).Text2) = string(local186)
10772         }
10773 }
10774
10775 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
10776         if err := pcall(func() {
10777                 ((*(*(struct {
10778                         // &^= Mask
10779                         // |= Flags
10780                         Flags, Mask HUDFlags
10781                 }))(obj)).Flags).serialize(w)
10782         }); err != nil {
10783                 if err == io.EOF {
10784                         chk(io.EOF)
10785                 }
10786                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10787         }
10788         if err := pcall(func() {
10789                 ((*(*(struct {
10790                         // &^= Mask
10791                         // |= Flags
10792                         Flags, Mask HUDFlags
10793                 }))(obj)).Mask).serialize(w)
10794         }); err != nil {
10795                 if err == io.EOF {
10796                         chk(io.EOF)
10797                 }
10798                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10799         }
10800 }
10801
10802 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
10803         if err := pcall(func() {
10804                 ((*(*(struct {
10805                         // &^= Mask
10806                         // |= Flags
10807                         Flags, Mask HUDFlags
10808                 }))(obj)).Flags).deserialize(r)
10809         }); err != nil {
10810                 if err == io.EOF {
10811                         chk(io.EOF)
10812                 }
10813                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10814         }
10815         if err := pcall(func() {
10816                 ((*(*(struct {
10817                         // &^= Mask
10818                         // |= Flags
10819                         Flags, Mask HUDFlags
10820                 }))(obj)).Mask).deserialize(r)
10821         }); err != nil {
10822                 if err == io.EOF {
10823                         chk(io.EOF)
10824                 }
10825                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDFlags", err))
10826         }
10827 }
10828
10829 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
10830         if err := pcall(func() {
10831                 ((*(*(struct {
10832                         Param HotbarParam
10833
10834                         //mt:if %s.Param == HotbarSize
10835                         //mt:const uint16(4) // Size of Size field.
10836                         Size int32
10837
10838                         //mt:if %s.Param != HotbarSize
10839                         Img Texture
10840                 }))(obj)).Param).serialize(w)
10841         }); err != nil {
10842                 if err == io.EOF {
10843                         chk(io.EOF)
10844                 }
10845                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HotbarParam", err))
10846         }
10847         if (*(*(struct {
10848                 Param HotbarParam
10849
10850                 //mt:if %s.Param == HotbarSize
10851                 //mt:const uint16(4) // Size of Size field.
10852                 Size int32
10853
10854                 //mt:if %s.Param != HotbarSize
10855                 Img Texture
10856         }))(obj)).Param == HotbarSize {
10857                 {
10858                         local188 := uint16(4) // Size of Size field.
10859                         {
10860                                 x := local188
10861                                 write16(w, uint16(x))
10862                         }
10863                 }
10864                 {
10865                         x := (*(*(struct {
10866                                 Param HotbarParam
10867
10868                                 //mt:if %s.Param == HotbarSize
10869                                 //mt:const uint16(4) // Size of Size field.
10870                                 Size int32
10871
10872                                 //mt:if %s.Param != HotbarSize
10873                                 Img Texture
10874                         }))(obj)).Size
10875                         write32(w, uint32(x))
10876                 }
10877         }
10878         if (*(*(struct {
10879                 Param HotbarParam
10880
10881                 //mt:if %s.Param == HotbarSize
10882                 //mt:const uint16(4) // Size of Size field.
10883                 Size int32
10884
10885                 //mt:if %s.Param != HotbarSize
10886                 Img Texture
10887         }))(obj)).Param != HotbarSize {
10888                 if err := pcall(func() {
10889                         ((*(*(struct {
10890                                 Param HotbarParam
10891
10892                                 //mt:if %s.Param == HotbarSize
10893                                 //mt:const uint16(4) // Size of Size field.
10894                                 Size int32
10895
10896                                 //mt:if %s.Param != HotbarSize
10897                                 Img Texture
10898                         }))(obj)).Img).serialize(w)
10899                 }); err != nil {
10900                         if err == io.EOF {
10901                                 chk(io.EOF)
10902                         }
10903                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
10904                 }
10905         }
10906 }
10907
10908 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
10909         if err := pcall(func() {
10910                 ((*(*(struct {
10911                         Param HotbarParam
10912
10913                         //mt:if %s.Param == HotbarSize
10914                         //mt:const uint16(4) // Size of Size field.
10915                         Size int32
10916
10917                         //mt:if %s.Param != HotbarSize
10918                         Img Texture
10919                 }))(obj)).Param).deserialize(r)
10920         }); err != nil {
10921                 if err == io.EOF {
10922                         chk(io.EOF)
10923                 }
10924                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HotbarParam", err))
10925         }
10926         if (*(*(struct {
10927                 Param HotbarParam
10928
10929                 //mt:if %s.Param == HotbarSize
10930                 //mt:const uint16(4) // Size of Size field.
10931                 Size int32
10932
10933                 //mt:if %s.Param != HotbarSize
10934                 Img Texture
10935         }))(obj)).Param == HotbarSize {
10936                 {
10937                         var local189 uint16
10938                         local190 := uint16(4) // Size of Size field.
10939                         {
10940                                 p := &local189
10941                                 *p = read16(r)
10942                         }
10943                         if local189 != local190 {
10944                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
10945                         }
10946                 }
10947                 {
10948                         p := &(*(*(struct {
10949                                 Param HotbarParam
10950
10951                                 //mt:if %s.Param == HotbarSize
10952                                 //mt:const uint16(4) // Size of Size field.
10953                                 Size int32
10954
10955                                 //mt:if %s.Param != HotbarSize
10956                                 Img Texture
10957                         }))(obj)).Size
10958                         *p = int32(read32(r))
10959                 }
10960         }
10961         if (*(*(struct {
10962                 Param HotbarParam
10963
10964                 //mt:if %s.Param == HotbarSize
10965                 //mt:const uint16(4) // Size of Size field.
10966                 Size int32
10967
10968                 //mt:if %s.Param != HotbarSize
10969                 Img Texture
10970         }))(obj)).Param != HotbarSize {
10971                 if err := pcall(func() {
10972                         ((*(*(struct {
10973                                 Param HotbarParam
10974
10975                                 //mt:if %s.Param == HotbarSize
10976                                 //mt:const uint16(4) // Size of Size field.
10977                                 Size int32
10978
10979                                 //mt:if %s.Param != HotbarSize
10980                                 Img Texture
10981                         }))(obj)).Img).deserialize(r)
10982                 }); err != nil {
10983                         if err == io.EOF {
10984                                 chk(io.EOF)
10985                         }
10986                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
10987                 }
10988         }
10989 }
10990
10991 func (obj *ToCltBreath) serialize(w io.Writer) {
10992         {
10993                 x := (*(*(struct {
10994                         Breath uint16
10995                 }))(obj)).Breath
10996                 write16(w, uint16(x))
10997         }
10998 }
10999
11000 func (obj *ToCltBreath) deserialize(r io.Reader) {
11001         {
11002                 p := &(*(*(struct {
11003                         Breath uint16
11004                 }))(obj)).Breath
11005                 *p = read16(r)
11006         }
11007 }
11008
11009 func (obj *ToCltSkyParams) serialize(w io.Writer) {
11010         {
11011                 x := (*(*(struct {
11012                         BgColor     color.NRGBA
11013                         Type        string
11014                         Clouds      bool
11015                         SunFogTint  color.NRGBA
11016                         MoonFogTint color.NRGBA
11017                         FogTintType string
11018
11019                         //mt:if %s.Type == "skybox"
11020                         Textures []Texture
11021
11022                         //mt:if %s.Type == "regular"
11023                         DaySky, DayHorizon,
11024                         DawnSky, DawnHorizon,
11025                         NightSky, NightHorizon,
11026                         Indoor color.NRGBA
11027                 }))(obj)).BgColor
11028                 w.Write([]byte{x.A, x.R, x.G, x.B})
11029
11030         }
11031         if len(([]byte((*(*(struct {
11032                 BgColor     color.NRGBA
11033                 Type        string
11034                 Clouds      bool
11035                 SunFogTint  color.NRGBA
11036                 MoonFogTint color.NRGBA
11037                 FogTintType string
11038
11039                 //mt:if %s.Type == "skybox"
11040                 Textures []Texture
11041
11042                 //mt:if %s.Type == "regular"
11043                 DaySky, DayHorizon,
11044                 DawnSky, DawnHorizon,
11045                 NightSky, NightHorizon,
11046                 Indoor color.NRGBA
11047         }))(obj)).Type))) > math.MaxUint16 {
11048                 chk(ErrTooLong)
11049         }
11050         {
11051                 x := uint16(len(([]byte((*(*(struct {
11052                         BgColor     color.NRGBA
11053                         Type        string
11054                         Clouds      bool
11055                         SunFogTint  color.NRGBA
11056                         MoonFogTint color.NRGBA
11057                         FogTintType string
11058
11059                         //mt:if %s.Type == "skybox"
11060                         Textures []Texture
11061
11062                         //mt:if %s.Type == "regular"
11063                         DaySky, DayHorizon,
11064                         DawnSky, DawnHorizon,
11065                         NightSky, NightHorizon,
11066                         Indoor color.NRGBA
11067                 }))(obj)).Type))))
11068                 write16(w, uint16(x))
11069         }
11070         {
11071                 _, err := w.Write(([]byte((*(*(struct {
11072                         BgColor     color.NRGBA
11073                         Type        string
11074                         Clouds      bool
11075                         SunFogTint  color.NRGBA
11076                         MoonFogTint color.NRGBA
11077                         FogTintType string
11078
11079                         //mt:if %s.Type == "skybox"
11080                         Textures []Texture
11081
11082                         //mt:if %s.Type == "regular"
11083                         DaySky, DayHorizon,
11084                         DawnSky, DawnHorizon,
11085                         NightSky, NightHorizon,
11086                         Indoor color.NRGBA
11087                 }))(obj)).Type))[:])
11088                 chk(err)
11089         }
11090         {
11091                 x := (*(*(struct {
11092                         BgColor     color.NRGBA
11093                         Type        string
11094                         Clouds      bool
11095                         SunFogTint  color.NRGBA
11096                         MoonFogTint color.NRGBA
11097                         FogTintType string
11098
11099                         //mt:if %s.Type == "skybox"
11100                         Textures []Texture
11101
11102                         //mt:if %s.Type == "regular"
11103                         DaySky, DayHorizon,
11104                         DawnSky, DawnHorizon,
11105                         NightSky, NightHorizon,
11106                         Indoor color.NRGBA
11107                 }))(obj)).Clouds
11108                 if x {
11109                         write8(w, 1)
11110                 } else {
11111                         write8(w, 0)
11112                 }
11113
11114         }
11115         {
11116                 x := (*(*(struct {
11117                         BgColor     color.NRGBA
11118                         Type        string
11119                         Clouds      bool
11120                         SunFogTint  color.NRGBA
11121                         MoonFogTint color.NRGBA
11122                         FogTintType string
11123
11124                         //mt:if %s.Type == "skybox"
11125                         Textures []Texture
11126
11127                         //mt:if %s.Type == "regular"
11128                         DaySky, DayHorizon,
11129                         DawnSky, DawnHorizon,
11130                         NightSky, NightHorizon,
11131                         Indoor color.NRGBA
11132                 }))(obj)).SunFogTint
11133                 w.Write([]byte{x.A, x.R, x.G, x.B})
11134
11135         }
11136         {
11137                 x := (*(*(struct {
11138                         BgColor     color.NRGBA
11139                         Type        string
11140                         Clouds      bool
11141                         SunFogTint  color.NRGBA
11142                         MoonFogTint color.NRGBA
11143                         FogTintType string
11144
11145                         //mt:if %s.Type == "skybox"
11146                         Textures []Texture
11147
11148                         //mt:if %s.Type == "regular"
11149                         DaySky, DayHorizon,
11150                         DawnSky, DawnHorizon,
11151                         NightSky, NightHorizon,
11152                         Indoor color.NRGBA
11153                 }))(obj)).MoonFogTint
11154                 w.Write([]byte{x.A, x.R, x.G, x.B})
11155
11156         }
11157         if len(([]byte((*(*(struct {
11158                 BgColor     color.NRGBA
11159                 Type        string
11160                 Clouds      bool
11161                 SunFogTint  color.NRGBA
11162                 MoonFogTint color.NRGBA
11163                 FogTintType string
11164
11165                 //mt:if %s.Type == "skybox"
11166                 Textures []Texture
11167
11168                 //mt:if %s.Type == "regular"
11169                 DaySky, DayHorizon,
11170                 DawnSky, DawnHorizon,
11171                 NightSky, NightHorizon,
11172                 Indoor color.NRGBA
11173         }))(obj)).FogTintType))) > math.MaxUint16 {
11174                 chk(ErrTooLong)
11175         }
11176         {
11177                 x := uint16(len(([]byte((*(*(struct {
11178                         BgColor     color.NRGBA
11179                         Type        string
11180                         Clouds      bool
11181                         SunFogTint  color.NRGBA
11182                         MoonFogTint color.NRGBA
11183                         FogTintType string
11184
11185                         //mt:if %s.Type == "skybox"
11186                         Textures []Texture
11187
11188                         //mt:if %s.Type == "regular"
11189                         DaySky, DayHorizon,
11190                         DawnSky, DawnHorizon,
11191                         NightSky, NightHorizon,
11192                         Indoor color.NRGBA
11193                 }))(obj)).FogTintType))))
11194                 write16(w, uint16(x))
11195         }
11196         {
11197                 _, err := w.Write(([]byte((*(*(struct {
11198                         BgColor     color.NRGBA
11199                         Type        string
11200                         Clouds      bool
11201                         SunFogTint  color.NRGBA
11202                         MoonFogTint color.NRGBA
11203                         FogTintType string
11204
11205                         //mt:if %s.Type == "skybox"
11206                         Textures []Texture
11207
11208                         //mt:if %s.Type == "regular"
11209                         DaySky, DayHorizon,
11210                         DawnSky, DawnHorizon,
11211                         NightSky, NightHorizon,
11212                         Indoor color.NRGBA
11213                 }))(obj)).FogTintType))[:])
11214                 chk(err)
11215         }
11216         if (*(*(struct {
11217                 BgColor     color.NRGBA
11218                 Type        string
11219                 Clouds      bool
11220                 SunFogTint  color.NRGBA
11221                 MoonFogTint color.NRGBA
11222                 FogTintType string
11223
11224                 //mt:if %s.Type == "skybox"
11225                 Textures []Texture
11226
11227                 //mt:if %s.Type == "regular"
11228                 DaySky, DayHorizon,
11229                 DawnSky, DawnHorizon,
11230                 NightSky, NightHorizon,
11231                 Indoor color.NRGBA
11232         }))(obj)).Type == "skybox" {
11233                 if len(((*(*(struct {
11234                         BgColor     color.NRGBA
11235                         Type        string
11236                         Clouds      bool
11237                         SunFogTint  color.NRGBA
11238                         MoonFogTint color.NRGBA
11239                         FogTintType string
11240
11241                         //mt:if %s.Type == "skybox"
11242                         Textures []Texture
11243
11244                         //mt:if %s.Type == "regular"
11245                         DaySky, DayHorizon,
11246                         DawnSky, DawnHorizon,
11247                         NightSky, NightHorizon,
11248                         Indoor color.NRGBA
11249                 }))(obj)).Textures)) > math.MaxUint16 {
11250                         chk(ErrTooLong)
11251                 }
11252                 {
11253                         x := uint16(len(((*(*(struct {
11254                                 BgColor     color.NRGBA
11255                                 Type        string
11256                                 Clouds      bool
11257                                 SunFogTint  color.NRGBA
11258                                 MoonFogTint color.NRGBA
11259                                 FogTintType string
11260
11261                                 //mt:if %s.Type == "skybox"
11262                                 Textures []Texture
11263
11264                                 //mt:if %s.Type == "regular"
11265                                 DaySky, DayHorizon,
11266                                 DawnSky, DawnHorizon,
11267                                 NightSky, NightHorizon,
11268                                 Indoor color.NRGBA
11269                         }))(obj)).Textures)))
11270                         write16(w, uint16(x))
11271                 }
11272                 for local191 := range (*(*(struct {
11273                         BgColor     color.NRGBA
11274                         Type        string
11275                         Clouds      bool
11276                         SunFogTint  color.NRGBA
11277                         MoonFogTint color.NRGBA
11278                         FogTintType string
11279
11280                         //mt:if %s.Type == "skybox"
11281                         Textures []Texture
11282
11283                         //mt:if %s.Type == "regular"
11284                         DaySky, DayHorizon,
11285                         DawnSky, DawnHorizon,
11286                         NightSky, NightHorizon,
11287                         Indoor color.NRGBA
11288                 }))(obj)).Textures {
11289                         if err := pcall(func() {
11290                                 (((*(*(struct {
11291                                         BgColor     color.NRGBA
11292                                         Type        string
11293                                         Clouds      bool
11294                                         SunFogTint  color.NRGBA
11295                                         MoonFogTint color.NRGBA
11296                                         FogTintType string
11297
11298                                         //mt:if %s.Type == "skybox"
11299                                         Textures []Texture
11300
11301                                         //mt:if %s.Type == "regular"
11302                                         DaySky, DayHorizon,
11303                                         DawnSky, DawnHorizon,
11304                                         NightSky, NightHorizon,
11305                                         Indoor color.NRGBA
11306                                 }))(obj)).Textures)[local191]).serialize(w)
11307                         }); err != nil {
11308                                 if err == io.EOF {
11309                                         chk(io.EOF)
11310                                 }
11311                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
11312                         }
11313                 }
11314         }
11315         if (*(*(struct {
11316                 BgColor     color.NRGBA
11317                 Type        string
11318                 Clouds      bool
11319                 SunFogTint  color.NRGBA
11320                 MoonFogTint color.NRGBA
11321                 FogTintType string
11322
11323                 //mt:if %s.Type == "skybox"
11324                 Textures []Texture
11325
11326                 //mt:if %s.Type == "regular"
11327                 DaySky, DayHorizon,
11328                 DawnSky, DawnHorizon,
11329                 NightSky, NightHorizon,
11330                 Indoor color.NRGBA
11331         }))(obj)).Type == "regular" {
11332                 {
11333                         x := (*(*(struct {
11334                                 BgColor     color.NRGBA
11335                                 Type        string
11336                                 Clouds      bool
11337                                 SunFogTint  color.NRGBA
11338                                 MoonFogTint color.NRGBA
11339                                 FogTintType string
11340
11341                                 //mt:if %s.Type == "skybox"
11342                                 Textures []Texture
11343
11344                                 //mt:if %s.Type == "regular"
11345                                 DaySky, DayHorizon,
11346                                 DawnSky, DawnHorizon,
11347                                 NightSky, NightHorizon,
11348                                 Indoor color.NRGBA
11349                         }))(obj)).DaySky
11350                         w.Write([]byte{x.A, x.R, x.G, x.B})
11351
11352                 }
11353                 {
11354                         x := (*(*(struct {
11355                                 BgColor     color.NRGBA
11356                                 Type        string
11357                                 Clouds      bool
11358                                 SunFogTint  color.NRGBA
11359                                 MoonFogTint color.NRGBA
11360                                 FogTintType string
11361
11362                                 //mt:if %s.Type == "skybox"
11363                                 Textures []Texture
11364
11365                                 //mt:if %s.Type == "regular"
11366                                 DaySky, DayHorizon,
11367                                 DawnSky, DawnHorizon,
11368                                 NightSky, NightHorizon,
11369                                 Indoor color.NRGBA
11370                         }))(obj)).DayHorizon
11371                         w.Write([]byte{x.A, x.R, x.G, x.B})
11372
11373                 }
11374                 {
11375                         x := (*(*(struct {
11376                                 BgColor     color.NRGBA
11377                                 Type        string
11378                                 Clouds      bool
11379                                 SunFogTint  color.NRGBA
11380                                 MoonFogTint color.NRGBA
11381                                 FogTintType string
11382
11383                                 //mt:if %s.Type == "skybox"
11384                                 Textures []Texture
11385
11386                                 //mt:if %s.Type == "regular"
11387                                 DaySky, DayHorizon,
11388                                 DawnSky, DawnHorizon,
11389                                 NightSky, NightHorizon,
11390                                 Indoor color.NRGBA
11391                         }))(obj)).DawnSky
11392                         w.Write([]byte{x.A, x.R, x.G, x.B})
11393
11394                 }
11395                 {
11396                         x := (*(*(struct {
11397                                 BgColor     color.NRGBA
11398                                 Type        string
11399                                 Clouds      bool
11400                                 SunFogTint  color.NRGBA
11401                                 MoonFogTint color.NRGBA
11402                                 FogTintType string
11403
11404                                 //mt:if %s.Type == "skybox"
11405                                 Textures []Texture
11406
11407                                 //mt:if %s.Type == "regular"
11408                                 DaySky, DayHorizon,
11409                                 DawnSky, DawnHorizon,
11410                                 NightSky, NightHorizon,
11411                                 Indoor color.NRGBA
11412                         }))(obj)).DawnHorizon
11413                         w.Write([]byte{x.A, x.R, x.G, x.B})
11414
11415                 }
11416                 {
11417                         x := (*(*(struct {
11418                                 BgColor     color.NRGBA
11419                                 Type        string
11420                                 Clouds      bool
11421                                 SunFogTint  color.NRGBA
11422                                 MoonFogTint color.NRGBA
11423                                 FogTintType string
11424
11425                                 //mt:if %s.Type == "skybox"
11426                                 Textures []Texture
11427
11428                                 //mt:if %s.Type == "regular"
11429                                 DaySky, DayHorizon,
11430                                 DawnSky, DawnHorizon,
11431                                 NightSky, NightHorizon,
11432                                 Indoor color.NRGBA
11433                         }))(obj)).NightSky
11434                         w.Write([]byte{x.A, x.R, x.G, x.B})
11435
11436                 }
11437                 {
11438                         x := (*(*(struct {
11439                                 BgColor     color.NRGBA
11440                                 Type        string
11441                                 Clouds      bool
11442                                 SunFogTint  color.NRGBA
11443                                 MoonFogTint color.NRGBA
11444                                 FogTintType string
11445
11446                                 //mt:if %s.Type == "skybox"
11447                                 Textures []Texture
11448
11449                                 //mt:if %s.Type == "regular"
11450                                 DaySky, DayHorizon,
11451                                 DawnSky, DawnHorizon,
11452                                 NightSky, NightHorizon,
11453                                 Indoor color.NRGBA
11454                         }))(obj)).NightHorizon
11455                         w.Write([]byte{x.A, x.R, x.G, x.B})
11456
11457                 }
11458                 {
11459                         x := (*(*(struct {
11460                                 BgColor     color.NRGBA
11461                                 Type        string
11462                                 Clouds      bool
11463                                 SunFogTint  color.NRGBA
11464                                 MoonFogTint color.NRGBA
11465                                 FogTintType string
11466
11467                                 //mt:if %s.Type == "skybox"
11468                                 Textures []Texture
11469
11470                                 //mt:if %s.Type == "regular"
11471                                 DaySky, DayHorizon,
11472                                 DawnSky, DawnHorizon,
11473                                 NightSky, NightHorizon,
11474                                 Indoor color.NRGBA
11475                         }))(obj)).Indoor
11476                         w.Write([]byte{x.A, x.R, x.G, x.B})
11477
11478                 }
11479         }
11480 }
11481
11482 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11483         {
11484                 p := &(*(*(struct {
11485                         BgColor     color.NRGBA
11486                         Type        string
11487                         Clouds      bool
11488                         SunFogTint  color.NRGBA
11489                         MoonFogTint color.NRGBA
11490                         FogTintType string
11491
11492                         //mt:if %s.Type == "skybox"
11493                         Textures []Texture
11494
11495                         //mt:if %s.Type == "regular"
11496                         DaySky, DayHorizon,
11497                         DawnSky, DawnHorizon,
11498                         NightSky, NightHorizon,
11499                         Indoor color.NRGBA
11500                 }))(obj)).BgColor
11501                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11502
11503         }
11504         var local192 []uint8
11505         var local193 uint16
11506         {
11507                 p := &local193
11508                 *p = read16(r)
11509         }
11510         (local192) = make([]uint8, local193)
11511         {
11512                 _, err := io.ReadFull(r, (local192)[:])
11513                 chk(err)
11514         }
11515         ((*(*(struct {
11516                 BgColor     color.NRGBA
11517                 Type        string
11518                 Clouds      bool
11519                 SunFogTint  color.NRGBA
11520                 MoonFogTint color.NRGBA
11521                 FogTintType string
11522
11523                 //mt:if %s.Type == "skybox"
11524                 Textures []Texture
11525
11526                 //mt:if %s.Type == "regular"
11527                 DaySky, DayHorizon,
11528                 DawnSky, DawnHorizon,
11529                 NightSky, NightHorizon,
11530                 Indoor color.NRGBA
11531         }))(obj)).Type) = string(local192)
11532         {
11533                 p := &(*(*(struct {
11534                         BgColor     color.NRGBA
11535                         Type        string
11536                         Clouds      bool
11537                         SunFogTint  color.NRGBA
11538                         MoonFogTint color.NRGBA
11539                         FogTintType string
11540
11541                         //mt:if %s.Type == "skybox"
11542                         Textures []Texture
11543
11544                         //mt:if %s.Type == "regular"
11545                         DaySky, DayHorizon,
11546                         DawnSky, DawnHorizon,
11547                         NightSky, NightHorizon,
11548                         Indoor color.NRGBA
11549                 }))(obj)).Clouds
11550                 switch n := read8(r); n {
11551                 case 0:
11552                         *p = false
11553                 case 1:
11554                         *p = true
11555                 default:
11556                         chk(fmt.Errorf("invalid bool: %d", n))
11557                 }
11558
11559         }
11560         {
11561                 p := &(*(*(struct {
11562                         BgColor     color.NRGBA
11563                         Type        string
11564                         Clouds      bool
11565                         SunFogTint  color.NRGBA
11566                         MoonFogTint color.NRGBA
11567                         FogTintType string
11568
11569                         //mt:if %s.Type == "skybox"
11570                         Textures []Texture
11571
11572                         //mt:if %s.Type == "regular"
11573                         DaySky, DayHorizon,
11574                         DawnSky, DawnHorizon,
11575                         NightSky, NightHorizon,
11576                         Indoor color.NRGBA
11577                 }))(obj)).SunFogTint
11578                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11579
11580         }
11581         {
11582                 p := &(*(*(struct {
11583                         BgColor     color.NRGBA
11584                         Type        string
11585                         Clouds      bool
11586                         SunFogTint  color.NRGBA
11587                         MoonFogTint color.NRGBA
11588                         FogTintType string
11589
11590                         //mt:if %s.Type == "skybox"
11591                         Textures []Texture
11592
11593                         //mt:if %s.Type == "regular"
11594                         DaySky, DayHorizon,
11595                         DawnSky, DawnHorizon,
11596                         NightSky, NightHorizon,
11597                         Indoor color.NRGBA
11598                 }))(obj)).MoonFogTint
11599                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11600
11601         }
11602         var local194 []uint8
11603         var local195 uint16
11604         {
11605                 p := &local195
11606                 *p = read16(r)
11607         }
11608         (local194) = make([]uint8, local195)
11609         {
11610                 _, err := io.ReadFull(r, (local194)[:])
11611                 chk(err)
11612         }
11613         ((*(*(struct {
11614                 BgColor     color.NRGBA
11615                 Type        string
11616                 Clouds      bool
11617                 SunFogTint  color.NRGBA
11618                 MoonFogTint color.NRGBA
11619                 FogTintType string
11620
11621                 //mt:if %s.Type == "skybox"
11622                 Textures []Texture
11623
11624                 //mt:if %s.Type == "regular"
11625                 DaySky, DayHorizon,
11626                 DawnSky, DawnHorizon,
11627                 NightSky, NightHorizon,
11628                 Indoor color.NRGBA
11629         }))(obj)).FogTintType) = string(local194)
11630         if (*(*(struct {
11631                 BgColor     color.NRGBA
11632                 Type        string
11633                 Clouds      bool
11634                 SunFogTint  color.NRGBA
11635                 MoonFogTint color.NRGBA
11636                 FogTintType string
11637
11638                 //mt:if %s.Type == "skybox"
11639                 Textures []Texture
11640
11641                 //mt:if %s.Type == "regular"
11642                 DaySky, DayHorizon,
11643                 DawnSky, DawnHorizon,
11644                 NightSky, NightHorizon,
11645                 Indoor color.NRGBA
11646         }))(obj)).Type == "skybox" {
11647                 var local196 uint16
11648                 {
11649                         p := &local196
11650                         *p = read16(r)
11651                 }
11652                 ((*(*(struct {
11653                         BgColor     color.NRGBA
11654                         Type        string
11655                         Clouds      bool
11656                         SunFogTint  color.NRGBA
11657                         MoonFogTint color.NRGBA
11658                         FogTintType string
11659
11660                         //mt:if %s.Type == "skybox"
11661                         Textures []Texture
11662
11663                         //mt:if %s.Type == "regular"
11664                         DaySky, DayHorizon,
11665                         DawnSky, DawnHorizon,
11666                         NightSky, NightHorizon,
11667                         Indoor color.NRGBA
11668                 }))(obj)).Textures) = make([]Texture, local196)
11669                 for local197 := range (*(*(struct {
11670                         BgColor     color.NRGBA
11671                         Type        string
11672                         Clouds      bool
11673                         SunFogTint  color.NRGBA
11674                         MoonFogTint color.NRGBA
11675                         FogTintType string
11676
11677                         //mt:if %s.Type == "skybox"
11678                         Textures []Texture
11679
11680                         //mt:if %s.Type == "regular"
11681                         DaySky, DayHorizon,
11682                         DawnSky, DawnHorizon,
11683                         NightSky, NightHorizon,
11684                         Indoor color.NRGBA
11685                 }))(obj)).Textures {
11686                         if err := pcall(func() {
11687                                 (((*(*(struct {
11688                                         BgColor     color.NRGBA
11689                                         Type        string
11690                                         Clouds      bool
11691                                         SunFogTint  color.NRGBA
11692                                         MoonFogTint color.NRGBA
11693                                         FogTintType string
11694
11695                                         //mt:if %s.Type == "skybox"
11696                                         Textures []Texture
11697
11698                                         //mt:if %s.Type == "regular"
11699                                         DaySky, DayHorizon,
11700                                         DawnSky, DawnHorizon,
11701                                         NightSky, NightHorizon,
11702                                         Indoor color.NRGBA
11703                                 }))(obj)).Textures)[local197]).deserialize(r)
11704                         }); err != nil {
11705                                 if err == io.EOF {
11706                                         chk(io.EOF)
11707                                 }
11708                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
11709                         }
11710                 }
11711         }
11712         if (*(*(struct {
11713                 BgColor     color.NRGBA
11714                 Type        string
11715                 Clouds      bool
11716                 SunFogTint  color.NRGBA
11717                 MoonFogTint color.NRGBA
11718                 FogTintType string
11719
11720                 //mt:if %s.Type == "skybox"
11721                 Textures []Texture
11722
11723                 //mt:if %s.Type == "regular"
11724                 DaySky, DayHorizon,
11725                 DawnSky, DawnHorizon,
11726                 NightSky, NightHorizon,
11727                 Indoor color.NRGBA
11728         }))(obj)).Type == "regular" {
11729                 {
11730                         p := &(*(*(struct {
11731                                 BgColor     color.NRGBA
11732                                 Type        string
11733                                 Clouds      bool
11734                                 SunFogTint  color.NRGBA
11735                                 MoonFogTint color.NRGBA
11736                                 FogTintType string
11737
11738                                 //mt:if %s.Type == "skybox"
11739                                 Textures []Texture
11740
11741                                 //mt:if %s.Type == "regular"
11742                                 DaySky, DayHorizon,
11743                                 DawnSky, DawnHorizon,
11744                                 NightSky, NightHorizon,
11745                                 Indoor color.NRGBA
11746                         }))(obj)).DaySky
11747                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11748
11749                 }
11750                 {
11751                         p := &(*(*(struct {
11752                                 BgColor     color.NRGBA
11753                                 Type        string
11754                                 Clouds      bool
11755                                 SunFogTint  color.NRGBA
11756                                 MoonFogTint color.NRGBA
11757                                 FogTintType string
11758
11759                                 //mt:if %s.Type == "skybox"
11760                                 Textures []Texture
11761
11762                                 //mt:if %s.Type == "regular"
11763                                 DaySky, DayHorizon,
11764                                 DawnSky, DawnHorizon,
11765                                 NightSky, NightHorizon,
11766                                 Indoor color.NRGBA
11767                         }))(obj)).DayHorizon
11768                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11769
11770                 }
11771                 {
11772                         p := &(*(*(struct {
11773                                 BgColor     color.NRGBA
11774                                 Type        string
11775                                 Clouds      bool
11776                                 SunFogTint  color.NRGBA
11777                                 MoonFogTint color.NRGBA
11778                                 FogTintType string
11779
11780                                 //mt:if %s.Type == "skybox"
11781                                 Textures []Texture
11782
11783                                 //mt:if %s.Type == "regular"
11784                                 DaySky, DayHorizon,
11785                                 DawnSky, DawnHorizon,
11786                                 NightSky, NightHorizon,
11787                                 Indoor color.NRGBA
11788                         }))(obj)).DawnSky
11789                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11790
11791                 }
11792                 {
11793                         p := &(*(*(struct {
11794                                 BgColor     color.NRGBA
11795                                 Type        string
11796                                 Clouds      bool
11797                                 SunFogTint  color.NRGBA
11798                                 MoonFogTint color.NRGBA
11799                                 FogTintType string
11800
11801                                 //mt:if %s.Type == "skybox"
11802                                 Textures []Texture
11803
11804                                 //mt:if %s.Type == "regular"
11805                                 DaySky, DayHorizon,
11806                                 DawnSky, DawnHorizon,
11807                                 NightSky, NightHorizon,
11808                                 Indoor color.NRGBA
11809                         }))(obj)).DawnHorizon
11810                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11811
11812                 }
11813                 {
11814                         p := &(*(*(struct {
11815                                 BgColor     color.NRGBA
11816                                 Type        string
11817                                 Clouds      bool
11818                                 SunFogTint  color.NRGBA
11819                                 MoonFogTint color.NRGBA
11820                                 FogTintType string
11821
11822                                 //mt:if %s.Type == "skybox"
11823                                 Textures []Texture
11824
11825                                 //mt:if %s.Type == "regular"
11826                                 DaySky, DayHorizon,
11827                                 DawnSky, DawnHorizon,
11828                                 NightSky, NightHorizon,
11829                                 Indoor color.NRGBA
11830                         }))(obj)).NightSky
11831                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11832
11833                 }
11834                 {
11835                         p := &(*(*(struct {
11836                                 BgColor     color.NRGBA
11837                                 Type        string
11838                                 Clouds      bool
11839                                 SunFogTint  color.NRGBA
11840                                 MoonFogTint color.NRGBA
11841                                 FogTintType string
11842
11843                                 //mt:if %s.Type == "skybox"
11844                                 Textures []Texture
11845
11846                                 //mt:if %s.Type == "regular"
11847                                 DaySky, DayHorizon,
11848                                 DawnSky, DawnHorizon,
11849                                 NightSky, NightHorizon,
11850                                 Indoor color.NRGBA
11851                         }))(obj)).NightHorizon
11852                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11853
11854                 }
11855                 {
11856                         p := &(*(*(struct {
11857                                 BgColor     color.NRGBA
11858                                 Type        string
11859                                 Clouds      bool
11860                                 SunFogTint  color.NRGBA
11861                                 MoonFogTint color.NRGBA
11862                                 FogTintType string
11863
11864                                 //mt:if %s.Type == "skybox"
11865                                 Textures []Texture
11866
11867                                 //mt:if %s.Type == "regular"
11868                                 DaySky, DayHorizon,
11869                                 DawnSky, DawnHorizon,
11870                                 NightSky, NightHorizon,
11871                                 Indoor color.NRGBA
11872                         }))(obj)).Indoor
11873                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11874
11875                 }
11876         }
11877 }
11878
11879 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
11880         {
11881                 x := (*(*(struct {
11882                         Override bool
11883                         Ratio    uint16
11884                 }))(obj)).Override
11885                 if x {
11886                         write8(w, 1)
11887                 } else {
11888                         write8(w, 0)
11889                 }
11890
11891         }
11892         {
11893                 x := (*(*(struct {
11894                         Override bool
11895                         Ratio    uint16
11896                 }))(obj)).Ratio
11897                 write16(w, uint16(x))
11898         }
11899 }
11900
11901 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
11902         {
11903                 p := &(*(*(struct {
11904                         Override bool
11905                         Ratio    uint16
11906                 }))(obj)).Override
11907                 switch n := read8(r); n {
11908                 case 0:
11909                         *p = false
11910                 case 1:
11911                         *p = true
11912                 default:
11913                         chk(fmt.Errorf("invalid bool: %d", n))
11914                 }
11915
11916         }
11917         {
11918                 p := &(*(*(struct {
11919                         Override bool
11920                         Ratio    uint16
11921                 }))(obj)).Ratio
11922                 *p = read16(r)
11923         }
11924 }
11925
11926 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
11927         for local198 := range (*(*(struct {
11928                 Idle, Walk, Dig, WalkDig [2]int32
11929                 Speed                    float32
11930         }))(obj)).Idle {
11931                 {
11932                         x := ((*(*(struct {
11933                                 Idle, Walk, Dig, WalkDig [2]int32
11934                                 Speed                    float32
11935                         }))(obj)).Idle)[local198]
11936                         write32(w, uint32(x))
11937                 }
11938         }
11939         for local199 := range (*(*(struct {
11940                 Idle, Walk, Dig, WalkDig [2]int32
11941                 Speed                    float32
11942         }))(obj)).Walk {
11943                 {
11944                         x := ((*(*(struct {
11945                                 Idle, Walk, Dig, WalkDig [2]int32
11946                                 Speed                    float32
11947                         }))(obj)).Walk)[local199]
11948                         write32(w, uint32(x))
11949                 }
11950         }
11951         for local200 := range (*(*(struct {
11952                 Idle, Walk, Dig, WalkDig [2]int32
11953                 Speed                    float32
11954         }))(obj)).Dig {
11955                 {
11956                         x := ((*(*(struct {
11957                                 Idle, Walk, Dig, WalkDig [2]int32
11958                                 Speed                    float32
11959                         }))(obj)).Dig)[local200]
11960                         write32(w, uint32(x))
11961                 }
11962         }
11963         for local201 := range (*(*(struct {
11964                 Idle, Walk, Dig, WalkDig [2]int32
11965                 Speed                    float32
11966         }))(obj)).WalkDig {
11967                 {
11968                         x := ((*(*(struct {
11969                                 Idle, Walk, Dig, WalkDig [2]int32
11970                                 Speed                    float32
11971                         }))(obj)).WalkDig)[local201]
11972                         write32(w, uint32(x))
11973                 }
11974         }
11975         {
11976                 x := (*(*(struct {
11977                         Idle, Walk, Dig, WalkDig [2]int32
11978                         Speed                    float32
11979                 }))(obj)).Speed
11980                 write32(w, math.Float32bits(x))
11981         }
11982 }
11983
11984 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
11985         for local202 := range (*(*(struct {
11986                 Idle, Walk, Dig, WalkDig [2]int32
11987                 Speed                    float32
11988         }))(obj)).Idle {
11989                 {
11990                         p := &((*(*(struct {
11991                                 Idle, Walk, Dig, WalkDig [2]int32
11992                                 Speed                    float32
11993                         }))(obj)).Idle)[local202]
11994                         *p = int32(read32(r))
11995                 }
11996         }
11997         for local203 := range (*(*(struct {
11998                 Idle, Walk, Dig, WalkDig [2]int32
11999                 Speed                    float32
12000         }))(obj)).Walk {
12001                 {
12002                         p := &((*(*(struct {
12003                                 Idle, Walk, Dig, WalkDig [2]int32
12004                                 Speed                    float32
12005                         }))(obj)).Walk)[local203]
12006                         *p = int32(read32(r))
12007                 }
12008         }
12009         for local204 := range (*(*(struct {
12010                 Idle, Walk, Dig, WalkDig [2]int32
12011                 Speed                    float32
12012         }))(obj)).Dig {
12013                 {
12014                         p := &((*(*(struct {
12015                                 Idle, Walk, Dig, WalkDig [2]int32
12016                                 Speed                    float32
12017                         }))(obj)).Dig)[local204]
12018                         *p = int32(read32(r))
12019                 }
12020         }
12021         for local205 := range (*(*(struct {
12022                 Idle, Walk, Dig, WalkDig [2]int32
12023                 Speed                    float32
12024         }))(obj)).WalkDig {
12025                 {
12026                         p := &((*(*(struct {
12027                                 Idle, Walk, Dig, WalkDig [2]int32
12028                                 Speed                    float32
12029                         }))(obj)).WalkDig)[local205]
12030                         *p = int32(read32(r))
12031                 }
12032         }
12033         {
12034                 p := &(*(*(struct {
12035                         Idle, Walk, Dig, WalkDig [2]int32
12036                         Speed                    float32
12037                 }))(obj)).Speed
12038                 *p = math.Float32frombits(read32(r))
12039         }
12040 }
12041
12042 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
12043         if err := pcall(func() {
12044                 ((*(*(struct {
12045                         First, Third Vec
12046                 }))(obj)).First).serialize(w)
12047         }); err != nil {
12048                 if err == io.EOF {
12049                         chk(io.EOF)
12050                 }
12051                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
12052         }
12053         if err := pcall(func() {
12054                 ((*(*(struct {
12055                         First, Third Vec
12056                 }))(obj)).Third).serialize(w)
12057         }); err != nil {
12058                 if err == io.EOF {
12059                         chk(io.EOF)
12060                 }
12061                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
12062         }
12063 }
12064
12065 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
12066         if err := pcall(func() {
12067                 ((*(*(struct {
12068                         First, Third Vec
12069                 }))(obj)).First).deserialize(r)
12070         }); err != nil {
12071                 if err == io.EOF {
12072                         chk(io.EOF)
12073                 }
12074                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
12075         }
12076         if err := pcall(func() {
12077                 ((*(*(struct {
12078                         First, Third Vec
12079                 }))(obj)).Third).deserialize(r)
12080         }); err != nil {
12081                 if err == io.EOF {
12082                         chk(io.EOF)
12083                 }
12084                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
12085         }
12086 }
12087
12088 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12089         if err := pcall(func() {
12090                 ((*(*(struct {
12091                         ID ParticleSpawnerID
12092                 }))(obj)).ID).serialize(w)
12093         }); err != nil {
12094                 if err == io.EOF {
12095                         chk(io.EOF)
12096                 }
12097                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
12098         }
12099 }
12100
12101 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12102         if err := pcall(func() {
12103                 ((*(*(struct {
12104                         ID ParticleSpawnerID
12105                 }))(obj)).ID).deserialize(r)
12106         }); err != nil {
12107                 if err == io.EOF {
12108                         chk(io.EOF)
12109                 }
12110                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ParticleSpawnerID", err))
12111         }
12112 }
12113
12114 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12115         {
12116                 x := (*(*(struct {
12117                         Density      float32
12118                         DiffuseColor color.NRGBA
12119                         AmbientColor color.NRGBA
12120                         Height       float32
12121                         Thickness    float32
12122                         Speed        [2]float32
12123                 }))(obj)).Density
12124                 write32(w, math.Float32bits(x))
12125         }
12126         {
12127                 x := (*(*(struct {
12128                         Density      float32
12129                         DiffuseColor color.NRGBA
12130                         AmbientColor color.NRGBA
12131                         Height       float32
12132                         Thickness    float32
12133                         Speed        [2]float32
12134                 }))(obj)).DiffuseColor
12135                 w.Write([]byte{x.A, x.R, x.G, x.B})
12136
12137         }
12138         {
12139                 x := (*(*(struct {
12140                         Density      float32
12141                         DiffuseColor color.NRGBA
12142                         AmbientColor color.NRGBA
12143                         Height       float32
12144                         Thickness    float32
12145                         Speed        [2]float32
12146                 }))(obj)).AmbientColor
12147                 w.Write([]byte{x.A, x.R, x.G, x.B})
12148
12149         }
12150         {
12151                 x := (*(*(struct {
12152                         Density      float32
12153                         DiffuseColor color.NRGBA
12154                         AmbientColor color.NRGBA
12155                         Height       float32
12156                         Thickness    float32
12157                         Speed        [2]float32
12158                 }))(obj)).Height
12159                 write32(w, math.Float32bits(x))
12160         }
12161         {
12162                 x := (*(*(struct {
12163                         Density      float32
12164                         DiffuseColor color.NRGBA
12165                         AmbientColor color.NRGBA
12166                         Height       float32
12167                         Thickness    float32
12168                         Speed        [2]float32
12169                 }))(obj)).Thickness
12170                 write32(w, math.Float32bits(x))
12171         }
12172         for local206 := range (*(*(struct {
12173                 Density      float32
12174                 DiffuseColor color.NRGBA
12175                 AmbientColor color.NRGBA
12176                 Height       float32
12177                 Thickness    float32
12178                 Speed        [2]float32
12179         }))(obj)).Speed {
12180                 {
12181                         x := ((*(*(struct {
12182                                 Density      float32
12183                                 DiffuseColor color.NRGBA
12184                                 AmbientColor color.NRGBA
12185                                 Height       float32
12186                                 Thickness    float32
12187                                 Speed        [2]float32
12188                         }))(obj)).Speed)[local206]
12189                         write32(w, math.Float32bits(x))
12190                 }
12191         }
12192 }
12193
12194 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12195         {
12196                 p := &(*(*(struct {
12197                         Density      float32
12198                         DiffuseColor color.NRGBA
12199                         AmbientColor color.NRGBA
12200                         Height       float32
12201                         Thickness    float32
12202                         Speed        [2]float32
12203                 }))(obj)).Density
12204                 *p = math.Float32frombits(read32(r))
12205         }
12206         {
12207                 p := &(*(*(struct {
12208                         Density      float32
12209                         DiffuseColor color.NRGBA
12210                         AmbientColor color.NRGBA
12211                         Height       float32
12212                         Thickness    float32
12213                         Speed        [2]float32
12214                 }))(obj)).DiffuseColor
12215                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12216
12217         }
12218         {
12219                 p := &(*(*(struct {
12220                         Density      float32
12221                         DiffuseColor color.NRGBA
12222                         AmbientColor color.NRGBA
12223                         Height       float32
12224                         Thickness    float32
12225                         Speed        [2]float32
12226                 }))(obj)).AmbientColor
12227                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12228
12229         }
12230         {
12231                 p := &(*(*(struct {
12232                         Density      float32
12233                         DiffuseColor color.NRGBA
12234                         AmbientColor color.NRGBA
12235                         Height       float32
12236                         Thickness    float32
12237                         Speed        [2]float32
12238                 }))(obj)).Height
12239                 *p = math.Float32frombits(read32(r))
12240         }
12241         {
12242                 p := &(*(*(struct {
12243                         Density      float32
12244                         DiffuseColor color.NRGBA
12245                         AmbientColor color.NRGBA
12246                         Height       float32
12247                         Thickness    float32
12248                         Speed        [2]float32
12249                 }))(obj)).Thickness
12250                 *p = math.Float32frombits(read32(r))
12251         }
12252         for local207 := range (*(*(struct {
12253                 Density      float32
12254                 DiffuseColor color.NRGBA
12255                 AmbientColor color.NRGBA
12256                 Height       float32
12257                 Thickness    float32
12258                 Speed        [2]float32
12259         }))(obj)).Speed {
12260                 {
12261                         p := &((*(*(struct {
12262                                 Density      float32
12263                                 DiffuseColor color.NRGBA
12264                                 AmbientColor color.NRGBA
12265                                 Height       float32
12266                                 Thickness    float32
12267                                 Speed        [2]float32
12268                         }))(obj)).Speed)[local207]
12269                         *p = math.Float32frombits(read32(r))
12270                 }
12271         }
12272 }
12273
12274 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12275         if err := pcall(func() {
12276                 ((*(*(struct {
12277                         ID   SoundID
12278                         Step float32
12279                         Gain float32
12280                 }))(obj)).ID).serialize(w)
12281         }); err != nil {
12282                 if err == io.EOF {
12283                         chk(io.EOF)
12284                 }
12285                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
12286         }
12287         {
12288                 x := (*(*(struct {
12289                         ID   SoundID
12290                         Step float32
12291                         Gain float32
12292                 }))(obj)).Step
12293                 write32(w, math.Float32bits(x))
12294         }
12295         {
12296                 x := (*(*(struct {
12297                         ID   SoundID
12298                         Step float32
12299                         Gain float32
12300                 }))(obj)).Gain
12301                 write32(w, math.Float32bits(x))
12302         }
12303 }
12304
12305 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12306         if err := pcall(func() {
12307                 ((*(*(struct {
12308                         ID   SoundID
12309                         Step float32
12310                         Gain float32
12311                 }))(obj)).ID).deserialize(r)
12312         }); err != nil {
12313                 if err == io.EOF {
12314                         chk(io.EOF)
12315                 }
12316                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundID", err))
12317         }
12318         {
12319                 p := &(*(*(struct {
12320                         ID   SoundID
12321                         Step float32
12322                         Gain float32
12323                 }))(obj)).Step
12324                 *p = math.Float32frombits(read32(r))
12325         }
12326         {
12327                 p := &(*(*(struct {
12328                         ID   SoundID
12329                         Step float32
12330                         Gain float32
12331                 }))(obj)).Gain
12332                 *p = math.Float32frombits(read32(r))
12333         }
12334 }
12335
12336 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12337         if err := pcall(func() {
12338                 ((*(*(struct {
12339                         Type    PlayerListUpdateType
12340                         Players []string
12341                 }))(obj)).Type).serialize(w)
12342         }); err != nil {
12343                 if err == io.EOF {
12344                         chk(io.EOF)
12345                 }
12346                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerListUpdateType", err))
12347         }
12348         if len(((*(*(struct {
12349                 Type    PlayerListUpdateType
12350                 Players []string
12351         }))(obj)).Players)) > math.MaxUint16 {
12352                 chk(ErrTooLong)
12353         }
12354         {
12355                 x := uint16(len(((*(*(struct {
12356                         Type    PlayerListUpdateType
12357                         Players []string
12358                 }))(obj)).Players)))
12359                 write16(w, uint16(x))
12360         }
12361         for local208 := range (*(*(struct {
12362                 Type    PlayerListUpdateType
12363                 Players []string
12364         }))(obj)).Players {
12365                 if len(([]byte(((*(*(struct {
12366                         Type    PlayerListUpdateType
12367                         Players []string
12368                 }))(obj)).Players)[local208]))) > math.MaxUint16 {
12369                         chk(ErrTooLong)
12370                 }
12371                 {
12372                         x := uint16(len(([]byte(((*(*(struct {
12373                                 Type    PlayerListUpdateType
12374                                 Players []string
12375                         }))(obj)).Players)[local208]))))
12376                         write16(w, uint16(x))
12377                 }
12378                 {
12379                         _, err := w.Write(([]byte(((*(*(struct {
12380                                 Type    PlayerListUpdateType
12381                                 Players []string
12382                         }))(obj)).Players)[local208]))[:])
12383                         chk(err)
12384                 }
12385         }
12386 }
12387
12388 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12389         if err := pcall(func() {
12390                 ((*(*(struct {
12391                         Type    PlayerListUpdateType
12392                         Players []string
12393                 }))(obj)).Type).deserialize(r)
12394         }); err != nil {
12395                 if err == io.EOF {
12396                         chk(io.EOF)
12397                 }
12398                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.PlayerListUpdateType", err))
12399         }
12400         var local209 uint16
12401         {
12402                 p := &local209
12403                 *p = read16(r)
12404         }
12405         ((*(*(struct {
12406                 Type    PlayerListUpdateType
12407                 Players []string
12408         }))(obj)).Players) = make([]string, local209)
12409         for local210 := range (*(*(struct {
12410                 Type    PlayerListUpdateType
12411                 Players []string
12412         }))(obj)).Players {
12413                 var local211 []uint8
12414                 var local212 uint16
12415                 {
12416                         p := &local212
12417                         *p = read16(r)
12418                 }
12419                 (local211) = make([]uint8, local212)
12420                 {
12421                         _, err := io.ReadFull(r, (local211)[:])
12422                         chk(err)
12423                 }
12424                 (((*(*(struct {
12425                         Type    PlayerListUpdateType
12426                         Players []string
12427                 }))(obj)).Players)[local210]) = string(local211)
12428         }
12429 }
12430
12431 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12432         if len(([]byte((*(*(struct {
12433                 Channel string
12434                 Sender  string
12435                 Msg     string
12436         }))(obj)).Channel))) > math.MaxUint16 {
12437                 chk(ErrTooLong)
12438         }
12439         {
12440                 x := uint16(len(([]byte((*(*(struct {
12441                         Channel string
12442                         Sender  string
12443                         Msg     string
12444                 }))(obj)).Channel))))
12445                 write16(w, uint16(x))
12446         }
12447         {
12448                 _, err := w.Write(([]byte((*(*(struct {
12449                         Channel string
12450                         Sender  string
12451                         Msg     string
12452                 }))(obj)).Channel))[:])
12453                 chk(err)
12454         }
12455         if len(([]byte((*(*(struct {
12456                 Channel string
12457                 Sender  string
12458                 Msg     string
12459         }))(obj)).Sender))) > math.MaxUint16 {
12460                 chk(ErrTooLong)
12461         }
12462         {
12463                 x := uint16(len(([]byte((*(*(struct {
12464                         Channel string
12465                         Sender  string
12466                         Msg     string
12467                 }))(obj)).Sender))))
12468                 write16(w, uint16(x))
12469         }
12470         {
12471                 _, err := w.Write(([]byte((*(*(struct {
12472                         Channel string
12473                         Sender  string
12474                         Msg     string
12475                 }))(obj)).Sender))[:])
12476                 chk(err)
12477         }
12478         if len(([]byte((*(*(struct {
12479                 Channel string
12480                 Sender  string
12481                 Msg     string
12482         }))(obj)).Msg))) > math.MaxUint16 {
12483                 chk(ErrTooLong)
12484         }
12485         {
12486                 x := uint16(len(([]byte((*(*(struct {
12487                         Channel string
12488                         Sender  string
12489                         Msg     string
12490                 }))(obj)).Msg))))
12491                 write16(w, uint16(x))
12492         }
12493         {
12494                 _, err := w.Write(([]byte((*(*(struct {
12495                         Channel string
12496                         Sender  string
12497                         Msg     string
12498                 }))(obj)).Msg))[:])
12499                 chk(err)
12500         }
12501 }
12502
12503 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12504         var local213 []uint8
12505         var local214 uint16
12506         {
12507                 p := &local214
12508                 *p = read16(r)
12509         }
12510         (local213) = make([]uint8, local214)
12511         {
12512                 _, err := io.ReadFull(r, (local213)[:])
12513                 chk(err)
12514         }
12515         ((*(*(struct {
12516                 Channel string
12517                 Sender  string
12518                 Msg     string
12519         }))(obj)).Channel) = string(local213)
12520         var local215 []uint8
12521         var local216 uint16
12522         {
12523                 p := &local216
12524                 *p = read16(r)
12525         }
12526         (local215) = make([]uint8, local216)
12527         {
12528                 _, err := io.ReadFull(r, (local215)[:])
12529                 chk(err)
12530         }
12531         ((*(*(struct {
12532                 Channel string
12533                 Sender  string
12534                 Msg     string
12535         }))(obj)).Sender) = string(local215)
12536         var local217 []uint8
12537         var local218 uint16
12538         {
12539                 p := &local218
12540                 *p = read16(r)
12541         }
12542         (local217) = make([]uint8, local218)
12543         {
12544                 _, err := io.ReadFull(r, (local217)[:])
12545                 chk(err)
12546         }
12547         ((*(*(struct {
12548                 Channel string
12549                 Sender  string
12550                 Msg     string
12551         }))(obj)).Msg) = string(local217)
12552 }
12553
12554 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12555         if err := pcall(func() {
12556                 ((*(*(struct {
12557                         Signal  ModChanSig
12558                         Channel string
12559                 }))(obj)).Signal).serialize(w)
12560         }); err != nil {
12561                 if err == io.EOF {
12562                         chk(io.EOF)
12563                 }
12564                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ModChanSig", err))
12565         }
12566         if len(([]byte((*(*(struct {
12567                 Signal  ModChanSig
12568                 Channel string
12569         }))(obj)).Channel))) > math.MaxUint16 {
12570                 chk(ErrTooLong)
12571         }
12572         {
12573                 x := uint16(len(([]byte((*(*(struct {
12574                         Signal  ModChanSig
12575                         Channel string
12576                 }))(obj)).Channel))))
12577                 write16(w, uint16(x))
12578         }
12579         {
12580                 _, err := w.Write(([]byte((*(*(struct {
12581                         Signal  ModChanSig
12582                         Channel string
12583                 }))(obj)).Channel))[:])
12584                 chk(err)
12585         }
12586 }
12587
12588 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12589         if err := pcall(func() {
12590                 ((*(*(struct {
12591                         Signal  ModChanSig
12592                         Channel string
12593                 }))(obj)).Signal).deserialize(r)
12594         }); err != nil {
12595                 if err == io.EOF {
12596                         chk(io.EOF)
12597                 }
12598                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ModChanSig", err))
12599         }
12600         var local219 []uint8
12601         var local220 uint16
12602         {
12603                 p := &local220
12604                 *p = read16(r)
12605         }
12606         (local219) = make([]uint8, local220)
12607         {
12608                 _, err := io.ReadFull(r, (local219)[:])
12609                 chk(err)
12610         }
12611         ((*(*(struct {
12612                 Signal  ModChanSig
12613                 Channel string
12614         }))(obj)).Channel) = string(local219)
12615 }
12616
12617 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12618         {
12619                 ow := w
12620                 w := new(bytes.Buffer)
12621                 {
12622                         x := (*(*(struct {
12623                                 //mt:lenhdr 32
12624                                 Changed map[[3]int16]*NodeMeta
12625                         }))(obj)).Changed
12626                         {
12627                                 w := zlib.NewWriter(w)
12628
12629                                 if x == nil {
12630                                         write8(w, 0)
12631                                 } else {
12632                                         write8(w, 2)
12633                                         if len(x) > math.MaxUint16 {
12634                                                 chk(ErrTooLong)
12635                                         }
12636                                         write16(w, uint16(len(x)))
12637                                         keys := make([][3]int16, 0, len(x))
12638                                         for key := range x {
12639                                                 keys = append(keys, key)
12640                                         }
12641                                         sort.Slice(keys, func(i, j int) bool {
12642                                                 p, q := keys[i], keys[j]
12643
12644                                                 for i := range p {
12645                                                         switch {
12646                                                         case p[i] < q[i]:
12647                                                                 return true
12648                                                         case p[i] > q[i]:
12649                                                                 return false
12650                                                         }
12651                                                 }
12652
12653                                                 return false
12654                                         })
12655                                         for _, key := range keys {
12656                                                 for _, n := range key {
12657                                                         write16(w, uint16(n))
12658                                                 }
12659                                                 chk(serialize(w, x[key]))
12660                                         }
12661                                 }
12662
12663                                 chk(w.Close())
12664                         }
12665
12666                 }
12667                 {
12668                         buf := w
12669                         w := ow
12670                         if len((buf.Bytes())) > math.MaxUint32 {
12671                                 chk(ErrTooLong)
12672                         }
12673                         {
12674                                 x := uint32(len((buf.Bytes())))
12675                                 write32(w, uint32(x))
12676                         }
12677                         {
12678                                 _, err := w.Write((buf.Bytes())[:])
12679                                 chk(err)
12680                         }
12681                 }
12682         }
12683 }
12684
12685 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
12686         {
12687                 var n uint32
12688                 {
12689                         p := &n
12690                         *p = read32(r)
12691                 }
12692                 r := &io.LimitedReader{R: r, N: int64(n)}
12693                 {
12694                         p := &(*(*(struct {
12695                                 //mt:lenhdr 32
12696                                 Changed map[[3]int16]*NodeMeta
12697                         }))(obj)).Changed
12698                         {
12699                                 r, err := zlib.NewReader(byteReader{r})
12700                                 chk(err)
12701
12702                                 switch ver := read8(r); ver {
12703                                 case 0:
12704                                         *p = nil
12705                                 case 2:
12706                                         n := read16(r)
12707                                         *p = make(map[[3]int16]*NodeMeta, n)
12708                                         for ; n > 0; n-- {
12709                                                 var pos [3]int16
12710                                                 for i := range pos {
12711                                                         pos[i] = int16(read16(r))
12712                                                 }
12713                                                 nm := new(NodeMeta)
12714                                                 chk(deserialize(r, nm))
12715                                                 (*p)[pos] = nm
12716                                         }
12717                                 default:
12718                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
12719                                 }
12720
12721                                 chk(r.Close())
12722                         }
12723
12724                 }
12725                 if r.N > 0 {
12726                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
12727                 }
12728         }
12729 }
12730
12731 func (obj *ToCltSunParams) serialize(w io.Writer) {
12732         {
12733                 x := (*(*(struct {
12734                         Visible bool
12735                         Texture
12736                         ToneMap Texture
12737                         Rise    Texture
12738                         Rising  bool
12739                         Size    float32
12740                 }))(obj)).Visible
12741                 if x {
12742                         write8(w, 1)
12743                 } else {
12744                         write8(w, 0)
12745                 }
12746
12747         }
12748         if err := pcall(func() {
12749                 ((*(*(struct {
12750                         Visible bool
12751                         Texture
12752                         ToneMap Texture
12753                         Rise    Texture
12754                         Rising  bool
12755                         Size    float32
12756                 }))(obj)).Texture).serialize(w)
12757         }); err != nil {
12758                 if err == io.EOF {
12759                         chk(io.EOF)
12760                 }
12761                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12762         }
12763         if err := pcall(func() {
12764                 ((*(*(struct {
12765                         Visible bool
12766                         Texture
12767                         ToneMap Texture
12768                         Rise    Texture
12769                         Rising  bool
12770                         Size    float32
12771                 }))(obj)).ToneMap).serialize(w)
12772         }); err != nil {
12773                 if err == io.EOF {
12774                         chk(io.EOF)
12775                 }
12776                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12777         }
12778         if err := pcall(func() {
12779                 ((*(*(struct {
12780                         Visible bool
12781                         Texture
12782                         ToneMap Texture
12783                         Rise    Texture
12784                         Rising  bool
12785                         Size    float32
12786                 }))(obj)).Rise).serialize(w)
12787         }); err != nil {
12788                 if err == io.EOF {
12789                         chk(io.EOF)
12790                 }
12791                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12792         }
12793         {
12794                 x := (*(*(struct {
12795                         Visible bool
12796                         Texture
12797                         ToneMap Texture
12798                         Rise    Texture
12799                         Rising  bool
12800                         Size    float32
12801                 }))(obj)).Rising
12802                 if x {
12803                         write8(w, 1)
12804                 } else {
12805                         write8(w, 0)
12806                 }
12807
12808         }
12809         {
12810                 x := (*(*(struct {
12811                         Visible bool
12812                         Texture
12813                         ToneMap Texture
12814                         Rise    Texture
12815                         Rising  bool
12816                         Size    float32
12817                 }))(obj)).Size
12818                 write32(w, math.Float32bits(x))
12819         }
12820 }
12821
12822 func (obj *ToCltSunParams) deserialize(r io.Reader) {
12823         {
12824                 p := &(*(*(struct {
12825                         Visible bool
12826                         Texture
12827                         ToneMap Texture
12828                         Rise    Texture
12829                         Rising  bool
12830                         Size    float32
12831                 }))(obj)).Visible
12832                 switch n := read8(r); n {
12833                 case 0:
12834                         *p = false
12835                 case 1:
12836                         *p = true
12837                 default:
12838                         chk(fmt.Errorf("invalid bool: %d", n))
12839                 }
12840
12841         }
12842         if err := pcall(func() {
12843                 ((*(*(struct {
12844                         Visible bool
12845                         Texture
12846                         ToneMap Texture
12847                         Rise    Texture
12848                         Rising  bool
12849                         Size    float32
12850                 }))(obj)).Texture).deserialize(r)
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                         Rise    Texture
12863                         Rising  bool
12864                         Size    float32
12865                 }))(obj)).ToneMap).deserialize(r)
12866         }); err != nil {
12867                 if err == io.EOF {
12868                         chk(io.EOF)
12869                 }
12870                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12871         }
12872         if err := pcall(func() {
12873                 ((*(*(struct {
12874                         Visible bool
12875                         Texture
12876                         ToneMap Texture
12877                         Rise    Texture
12878                         Rising  bool
12879                         Size    float32
12880                 }))(obj)).Rise).deserialize(r)
12881         }); err != nil {
12882                 if err == io.EOF {
12883                         chk(io.EOF)
12884                 }
12885                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12886         }
12887         {
12888                 p := &(*(*(struct {
12889                         Visible bool
12890                         Texture
12891                         ToneMap Texture
12892                         Rise    Texture
12893                         Rising  bool
12894                         Size    float32
12895                 }))(obj)).Rising
12896                 switch n := read8(r); n {
12897                 case 0:
12898                         *p = false
12899                 case 1:
12900                         *p = true
12901                 default:
12902                         chk(fmt.Errorf("invalid bool: %d", n))
12903                 }
12904
12905         }
12906         {
12907                 p := &(*(*(struct {
12908                         Visible bool
12909                         Texture
12910                         ToneMap Texture
12911                         Rise    Texture
12912                         Rising  bool
12913                         Size    float32
12914                 }))(obj)).Size
12915                 *p = math.Float32frombits(read32(r))
12916         }
12917 }
12918
12919 func (obj *ToCltMoonParams) serialize(w io.Writer) {
12920         {
12921                 x := (*(*(struct {
12922                         Visible bool
12923                         Texture
12924                         ToneMap Texture
12925                         Size    float32
12926                 }))(obj)).Visible
12927                 if x {
12928                         write8(w, 1)
12929                 } else {
12930                         write8(w, 0)
12931                 }
12932
12933         }
12934         if err := pcall(func() {
12935                 ((*(*(struct {
12936                         Visible bool
12937                         Texture
12938                         ToneMap Texture
12939                         Size    float32
12940                 }))(obj)).Texture).serialize(w)
12941         }); err != nil {
12942                 if err == io.EOF {
12943                         chk(io.EOF)
12944                 }
12945                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12946         }
12947         if err := pcall(func() {
12948                 ((*(*(struct {
12949                         Visible bool
12950                         Texture
12951                         ToneMap Texture
12952                         Size    float32
12953                 }))(obj)).ToneMap).serialize(w)
12954         }); err != nil {
12955                 if err == io.EOF {
12956                         chk(io.EOF)
12957                 }
12958                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
12959         }
12960         {
12961                 x := (*(*(struct {
12962                         Visible bool
12963                         Texture
12964                         ToneMap Texture
12965                         Size    float32
12966                 }))(obj)).Size
12967                 write32(w, math.Float32bits(x))
12968         }
12969 }
12970
12971 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
12972         {
12973                 p := &(*(*(struct {
12974                         Visible bool
12975                         Texture
12976                         ToneMap Texture
12977                         Size    float32
12978                 }))(obj)).Visible
12979                 switch n := read8(r); n {
12980                 case 0:
12981                         *p = false
12982                 case 1:
12983                         *p = true
12984                 default:
12985                         chk(fmt.Errorf("invalid bool: %d", n))
12986                 }
12987
12988         }
12989         if err := pcall(func() {
12990                 ((*(*(struct {
12991                         Visible bool
12992                         Texture
12993                         ToneMap Texture
12994                         Size    float32
12995                 }))(obj)).Texture).deserialize(r)
12996         }); err != nil {
12997                 if err == io.EOF {
12998                         chk(io.EOF)
12999                 }
13000                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13001         }
13002         if err := pcall(func() {
13003                 ((*(*(struct {
13004                         Visible bool
13005                         Texture
13006                         ToneMap Texture
13007                         Size    float32
13008                 }))(obj)).ToneMap).deserialize(r)
13009         }); err != nil {
13010                 if err == io.EOF {
13011                         chk(io.EOF)
13012                 }
13013                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13014         }
13015         {
13016                 p := &(*(*(struct {
13017                         Visible bool
13018                         Texture
13019                         ToneMap Texture
13020                         Size    float32
13021                 }))(obj)).Size
13022                 *p = math.Float32frombits(read32(r))
13023         }
13024 }
13025
13026 func (obj *ToCltStarParams) serialize(w io.Writer) {
13027         {
13028                 x := (*(*(struct {
13029                         Visible bool
13030                         Count   uint32
13031                         Color   color.NRGBA
13032                         Size    float32
13033                 }))(obj)).Visible
13034                 if x {
13035                         write8(w, 1)
13036                 } else {
13037                         write8(w, 0)
13038                 }
13039
13040         }
13041         {
13042                 x := (*(*(struct {
13043                         Visible bool
13044                         Count   uint32
13045                         Color   color.NRGBA
13046                         Size    float32
13047                 }))(obj)).Count
13048                 write32(w, uint32(x))
13049         }
13050         {
13051                 x := (*(*(struct {
13052                         Visible bool
13053                         Count   uint32
13054                         Color   color.NRGBA
13055                         Size    float32
13056                 }))(obj)).Color
13057                 w.Write([]byte{x.A, x.R, x.G, x.B})
13058
13059         }
13060         {
13061                 x := (*(*(struct {
13062                         Visible bool
13063                         Count   uint32
13064                         Color   color.NRGBA
13065                         Size    float32
13066                 }))(obj)).Size
13067                 write32(w, math.Float32bits(x))
13068         }
13069 }
13070
13071 func (obj *ToCltStarParams) deserialize(r io.Reader) {
13072         {
13073                 p := &(*(*(struct {
13074                         Visible bool
13075                         Count   uint32
13076                         Color   color.NRGBA
13077                         Size    float32
13078                 }))(obj)).Visible
13079                 switch n := read8(r); n {
13080                 case 0:
13081                         *p = false
13082                 case 1:
13083                         *p = true
13084                 default:
13085                         chk(fmt.Errorf("invalid bool: %d", n))
13086                 }
13087
13088         }
13089         {
13090                 p := &(*(*(struct {
13091                         Visible bool
13092                         Count   uint32
13093                         Color   color.NRGBA
13094                         Size    float32
13095                 }))(obj)).Count
13096                 *p = read32(r)
13097         }
13098         {
13099                 p := &(*(*(struct {
13100                         Visible bool
13101                         Count   uint32
13102                         Color   color.NRGBA
13103                         Size    float32
13104                 }))(obj)).Color
13105                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13106
13107         }
13108         {
13109                 p := &(*(*(struct {
13110                         Visible bool
13111                         Count   uint32
13112                         Color   color.NRGBA
13113                         Size    float32
13114                 }))(obj)).Size
13115                 *p = math.Float32frombits(read32(r))
13116         }
13117 }
13118
13119 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13120         if len(((*(*(struct {
13121                 Salt, B []byte
13122         }))(obj)).Salt)) > math.MaxUint16 {
13123                 chk(ErrTooLong)
13124         }
13125         {
13126                 x := uint16(len(((*(*(struct {
13127                         Salt, B []byte
13128                 }))(obj)).Salt)))
13129                 write16(w, uint16(x))
13130         }
13131         {
13132                 _, err := w.Write(((*(*(struct {
13133                         Salt, B []byte
13134                 }))(obj)).Salt)[:])
13135                 chk(err)
13136         }
13137         if len(((*(*(struct {
13138                 Salt, B []byte
13139         }))(obj)).B)) > math.MaxUint16 {
13140                 chk(ErrTooLong)
13141         }
13142         {
13143                 x := uint16(len(((*(*(struct {
13144                         Salt, B []byte
13145                 }))(obj)).B)))
13146                 write16(w, uint16(x))
13147         }
13148         {
13149                 _, err := w.Write(((*(*(struct {
13150                         Salt, B []byte
13151                 }))(obj)).B)[:])
13152                 chk(err)
13153         }
13154 }
13155
13156 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13157         var local221 uint16
13158         {
13159                 p := &local221
13160                 *p = read16(r)
13161         }
13162         ((*(*(struct {
13163                 Salt, B []byte
13164         }))(obj)).Salt) = make([]byte, local221)
13165         {
13166                 _, err := io.ReadFull(r, ((*(*(struct {
13167                         Salt, B []byte
13168                 }))(obj)).Salt)[:])
13169                 chk(err)
13170         }
13171         var local222 uint16
13172         {
13173                 p := &local222
13174                 *p = read16(r)
13175         }
13176         ((*(*(struct {
13177                 Salt, B []byte
13178         }))(obj)).B) = make([]byte, local222)
13179         {
13180                 _, err := io.ReadFull(r, ((*(*(struct {
13181                         Salt, B []byte
13182                 }))(obj)).B)[:])
13183                 chk(err)
13184         }
13185 }
13186
13187 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13188         if len(([]byte((*(*(struct {
13189                 Prepend string
13190         }))(obj)).Prepend))) > math.MaxUint16 {
13191                 chk(ErrTooLong)
13192         }
13193         {
13194                 x := uint16(len(([]byte((*(*(struct {
13195                         Prepend string
13196                 }))(obj)).Prepend))))
13197                 write16(w, uint16(x))
13198         }
13199         {
13200                 _, err := w.Write(([]byte((*(*(struct {
13201                         Prepend string
13202                 }))(obj)).Prepend))[:])
13203                 chk(err)
13204         }
13205 }
13206
13207 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13208         var local223 []uint8
13209         var local224 uint16
13210         {
13211                 p := &local224
13212                 *p = read16(r)
13213         }
13214         (local223) = make([]uint8, local224)
13215         {
13216                 _, err := io.ReadFull(r, (local223)[:])
13217                 chk(err)
13218         }
13219         ((*(*(struct {
13220                 Prepend string
13221         }))(obj)).Prepend) = string(local223)
13222 }
13223
13224 func (obj *AOCmdProps) serialize(w io.Writer) {
13225         if err := pcall(func() {
13226                 ((*(*(struct {
13227                         Props AOProps
13228                 }))(obj)).Props).serialize(w)
13229         }); err != nil {
13230                 if err == io.EOF {
13231                         chk(io.EOF)
13232                 }
13233                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOProps", err))
13234         }
13235 }
13236
13237 func (obj *AOCmdProps) deserialize(r io.Reader) {
13238         if err := pcall(func() {
13239                 ((*(*(struct {
13240                         Props AOProps
13241                 }))(obj)).Props).deserialize(r)
13242         }); err != nil {
13243                 if err == io.EOF {
13244                         chk(io.EOF)
13245                 }
13246                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOProps", err))
13247         }
13248 }
13249
13250 func (obj *AOCmdPos) serialize(w io.Writer) {
13251         if err := pcall(func() {
13252                 ((*(*(struct {
13253                         Pos AOPos
13254                 }))(obj)).Pos).serialize(w)
13255         }); err != nil {
13256                 if err == io.EOF {
13257                         chk(io.EOF)
13258                 }
13259                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPos", err))
13260         }
13261 }
13262
13263 func (obj *AOCmdPos) deserialize(r io.Reader) {
13264         if err := pcall(func() {
13265                 ((*(*(struct {
13266                         Pos AOPos
13267                 }))(obj)).Pos).deserialize(r)
13268         }); err != nil {
13269                 if err == io.EOF {
13270                         chk(io.EOF)
13271                 }
13272                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPos", err))
13273         }
13274 }
13275
13276 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13277         if err := pcall(func() {
13278                 ((*(*(struct {
13279                         Mod Texture // suffix
13280                 }))(obj)).Mod).serialize(w)
13281         }); err != nil {
13282                 if err == io.EOF {
13283                         chk(io.EOF)
13284                 }
13285                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13286         }
13287 }
13288
13289 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13290         if err := pcall(func() {
13291                 ((*(*(struct {
13292                         Mod Texture // suffix
13293                 }))(obj)).Mod).deserialize(r)
13294         }); err != nil {
13295                 if err == io.EOF {
13296                         chk(io.EOF)
13297                 }
13298                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13299         }
13300 }
13301
13302 func (obj *AOCmdSprite) serialize(w io.Writer) {
13303         if err := pcall(func() {
13304                 ((*(*(struct {
13305                         Sprite AOSprite
13306                 }))(obj)).Sprite).serialize(w)
13307         }); err != nil {
13308                 if err == io.EOF {
13309                         chk(io.EOF)
13310                 }
13311                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOSprite", err))
13312         }
13313 }
13314
13315 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13316         if err := pcall(func() {
13317                 ((*(*(struct {
13318                         Sprite AOSprite
13319                 }))(obj)).Sprite).deserialize(r)
13320         }); err != nil {
13321                 if err == io.EOF {
13322                         chk(io.EOF)
13323                 }
13324                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOSprite", err))
13325         }
13326 }
13327
13328 func (obj *AOCmdHP) serialize(w io.Writer) {
13329         {
13330                 x := (*(*(struct {
13331                         HP uint16
13332                 }))(obj)).HP
13333                 write16(w, uint16(x))
13334         }
13335 }
13336
13337 func (obj *AOCmdHP) deserialize(r io.Reader) {
13338         {
13339                 p := &(*(*(struct {
13340                         HP uint16
13341                 }))(obj)).HP
13342                 *p = read16(r)
13343         }
13344 }
13345
13346 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13347         if len(((*(*(struct {
13348                 Armor []Group
13349         }))(obj)).Armor)) > math.MaxUint16 {
13350                 chk(ErrTooLong)
13351         }
13352         {
13353                 x := uint16(len(((*(*(struct {
13354                         Armor []Group
13355                 }))(obj)).Armor)))
13356                 write16(w, uint16(x))
13357         }
13358         for local225 := range (*(*(struct {
13359                 Armor []Group
13360         }))(obj)).Armor {
13361                 if err := pcall(func() {
13362                         (((*(*(struct {
13363                                 Armor []Group
13364                         }))(obj)).Armor)[local225]).serialize(w)
13365                 }); err != nil {
13366                         if err == io.EOF {
13367                                 chk(io.EOF)
13368                         }
13369                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
13370                 }
13371         }
13372 }
13373
13374 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13375         var local226 uint16
13376         {
13377                 p := &local226
13378                 *p = read16(r)
13379         }
13380         ((*(*(struct {
13381                 Armor []Group
13382         }))(obj)).Armor) = make([]Group, local226)
13383         for local227 := range (*(*(struct {
13384                 Armor []Group
13385         }))(obj)).Armor {
13386                 if err := pcall(func() {
13387                         (((*(*(struct {
13388                                 Armor []Group
13389                         }))(obj)).Armor)[local227]).deserialize(r)
13390                 }); err != nil {
13391                         if err == io.EOF {
13392                                 chk(io.EOF)
13393                         }
13394                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
13395                 }
13396         }
13397 }
13398
13399 func (obj *AOCmdAnim) serialize(w io.Writer) {
13400         if err := pcall(func() {
13401                 ((*(*(struct {
13402                         Anim AOAnim
13403                 }))(obj)).Anim).serialize(w)
13404         }); err != nil {
13405                 if err == io.EOF {
13406                         chk(io.EOF)
13407                 }
13408                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAnim", err))
13409         }
13410 }
13411
13412 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13413         if err := pcall(func() {
13414                 ((*(*(struct {
13415                         Anim AOAnim
13416                 }))(obj)).Anim).deserialize(r)
13417         }); err != nil {
13418                 if err == io.EOF {
13419                         chk(io.EOF)
13420                 }
13421                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAnim", err))
13422         }
13423 }
13424
13425 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13426         if len(([]byte((*(*(struct {
13427                 Bone string
13428                 Pos  AOBonePos
13429         }))(obj)).Bone))) > math.MaxUint16 {
13430                 chk(ErrTooLong)
13431         }
13432         {
13433                 x := uint16(len(([]byte((*(*(struct {
13434                         Bone string
13435                         Pos  AOBonePos
13436                 }))(obj)).Bone))))
13437                 write16(w, uint16(x))
13438         }
13439         {
13440                 _, err := w.Write(([]byte((*(*(struct {
13441                         Bone string
13442                         Pos  AOBonePos
13443                 }))(obj)).Bone))[:])
13444                 chk(err)
13445         }
13446         if err := pcall(func() {
13447                 ((*(*(struct {
13448                         Bone string
13449                         Pos  AOBonePos
13450                 }))(obj)).Pos).serialize(w)
13451         }); err != nil {
13452                 if err == io.EOF {
13453                         chk(io.EOF)
13454                 }
13455                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOBonePos", err))
13456         }
13457 }
13458
13459 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13460         var local228 []uint8
13461         var local229 uint16
13462         {
13463                 p := &local229
13464                 *p = read16(r)
13465         }
13466         (local228) = make([]uint8, local229)
13467         {
13468                 _, err := io.ReadFull(r, (local228)[:])
13469                 chk(err)
13470         }
13471         ((*(*(struct {
13472                 Bone string
13473                 Pos  AOBonePos
13474         }))(obj)).Bone) = string(local228)
13475         if err := pcall(func() {
13476                 ((*(*(struct {
13477                         Bone string
13478                         Pos  AOBonePos
13479                 }))(obj)).Pos).deserialize(r)
13480         }); err != nil {
13481                 if err == io.EOF {
13482                         chk(io.EOF)
13483                 }
13484                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOBonePos", err))
13485         }
13486 }
13487
13488 func (obj *AOCmdAttach) serialize(w io.Writer) {
13489         if err := pcall(func() {
13490                 ((*(*(struct {
13491                         Attach AOAttach
13492                 }))(obj)).Attach).serialize(w)
13493         }); err != nil {
13494                 if err == io.EOF {
13495                         chk(io.EOF)
13496                 }
13497                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAttach", err))
13498         }
13499 }
13500
13501 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13502         if err := pcall(func() {
13503                 ((*(*(struct {
13504                         Attach AOAttach
13505                 }))(obj)).Attach).deserialize(r)
13506         }); err != nil {
13507                 if err == io.EOF {
13508                         chk(io.EOF)
13509                 }
13510                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOAttach", err))
13511         }
13512 }
13513
13514 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13515         if err := pcall(func() {
13516                 ((*(*(struct {
13517                         Phys AOPhysOverride
13518                 }))(obj)).Phys).serialize(w)
13519         }); err != nil {
13520                 if err == io.EOF {
13521                         chk(io.EOF)
13522                 }
13523                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPhysOverride", err))
13524         }
13525 }
13526
13527 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13528         if err := pcall(func() {
13529                 ((*(*(struct {
13530                         Phys AOPhysOverride
13531                 }))(obj)).Phys).deserialize(r)
13532         }); err != nil {
13533                 if err == io.EOF {
13534                         chk(io.EOF)
13535                 }
13536                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOPhysOverride", err))
13537         }
13538 }
13539
13540 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13541         if err := pcall(func() {
13542                 ((*(*(struct {
13543                         ID AOID
13544                 }))(obj)).ID).serialize(w)
13545         }); err != nil {
13546                 if err == io.EOF {
13547                         chk(io.EOF)
13548                 }
13549                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
13550         }
13551         {
13552                 local230 := genericCAO
13553                 if err := pcall(func() {
13554                         (local230).serialize(w)
13555                 }); err != nil {
13556                         if err == io.EOF {
13557                                 chk(io.EOF)
13558                         }
13559                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
13560                 }
13561         }
13562 }
13563
13564 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13565         if err := pcall(func() {
13566                 ((*(*(struct {
13567                         ID AOID
13568                 }))(obj)).ID).deserialize(r)
13569         }); err != nil {
13570                 if err == io.EOF {
13571                         chk(io.EOF)
13572                 }
13573                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
13574         }
13575         {
13576                 var local231 aoType
13577                 local232 := genericCAO
13578                 if err := pcall(func() {
13579                         (local231).deserialize(r)
13580                 }); err != nil {
13581                         if err == io.EOF {
13582                                 chk(io.EOF)
13583                         }
13584                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
13585                 }
13586                 if local231 != local232 {
13587                         chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
13588                 }
13589         }
13590 }
13591
13592 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13593         {
13594                 x := (*(*(struct {
13595                         Speed float32
13596                 }))(obj)).Speed
13597                 write32(w, math.Float32bits(x))
13598         }
13599 }
13600
13601 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13602         {
13603                 p := &(*(*(struct {
13604                         Speed float32
13605                 }))(obj)).Speed
13606                 *p = math.Float32frombits(read32(r))
13607         }
13608 }
13609
13610 func (obj *NodeMeta) serialize(w io.Writer) {
13611         if len(((*(*(struct {
13612                 //mt:len32
13613                 Fields []NodeMetaField
13614
13615                 Inv Inv
13616         }))(obj)).Fields)) > math.MaxUint32 {
13617                 chk(ErrTooLong)
13618         }
13619         {
13620                 x := uint32(len(((*(*(struct {
13621                         //mt:len32
13622                         Fields []NodeMetaField
13623
13624                         Inv Inv
13625                 }))(obj)).Fields)))
13626                 write32(w, uint32(x))
13627         }
13628         for local233 := range (*(*(struct {
13629                 //mt:len32
13630                 Fields []NodeMetaField
13631
13632                 Inv Inv
13633         }))(obj)).Fields {
13634                 if err := pcall(func() {
13635                         (((*(*(struct {
13636                                 //mt:len32
13637                                 Fields []NodeMetaField
13638
13639                                 Inv Inv
13640                         }))(obj)).Fields)[local233]).serialize(w)
13641                 }); err != nil {
13642                         if err == io.EOF {
13643                                 chk(io.EOF)
13644                         }
13645                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeMetaField", err))
13646                 }
13647         }
13648         chk(((*(*(struct {
13649                 //mt:len32
13650                 Fields []NodeMetaField
13651
13652                 Inv Inv
13653         }))(obj)).Inv).Serialize(w))
13654 }
13655
13656 func (obj *NodeMeta) deserialize(r io.Reader) {
13657         var local234 uint32
13658         {
13659                 p := &local234
13660                 *p = read32(r)
13661         }
13662         ((*(*(struct {
13663                 //mt:len32
13664                 Fields []NodeMetaField
13665
13666                 Inv Inv
13667         }))(obj)).Fields) = make([]NodeMetaField, local234)
13668         for local235 := range (*(*(struct {
13669                 //mt:len32
13670                 Fields []NodeMetaField
13671
13672                 Inv Inv
13673         }))(obj)).Fields {
13674                 if err := pcall(func() {
13675                         (((*(*(struct {
13676                                 //mt:len32
13677                                 Fields []NodeMetaField
13678
13679                                 Inv Inv
13680                         }))(obj)).Fields)[local235]).deserialize(r)
13681                 }); err != nil {
13682                         if err == io.EOF {
13683                                 chk(io.EOF)
13684                         }
13685                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeMetaField", err))
13686                 }
13687         }
13688         chk(((*(*(struct {
13689                 //mt:len32
13690                 Fields []NodeMetaField
13691
13692                 Inv Inv
13693         }))(obj)).Inv).Deserialize(r))
13694 }
13695
13696 func (obj *MinimapMode) serialize(w io.Writer) {
13697         if err := pcall(func() {
13698                 ((*(*(struct {
13699                         Type  MinimapType
13700                         Label string
13701                         Size  uint16
13702                         Texture
13703                         Scale uint16
13704                 }))(obj)).Type).serialize(w)
13705         }); err != nil {
13706                 if err == io.EOF {
13707                         chk(io.EOF)
13708                 }
13709                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MinimapType", err))
13710         }
13711         if len(([]byte((*(*(struct {
13712                 Type  MinimapType
13713                 Label string
13714                 Size  uint16
13715                 Texture
13716                 Scale uint16
13717         }))(obj)).Label))) > math.MaxUint16 {
13718                 chk(ErrTooLong)
13719         }
13720         {
13721                 x := uint16(len(([]byte((*(*(struct {
13722                         Type  MinimapType
13723                         Label string
13724                         Size  uint16
13725                         Texture
13726                         Scale uint16
13727                 }))(obj)).Label))))
13728                 write16(w, uint16(x))
13729         }
13730         {
13731                 _, err := w.Write(([]byte((*(*(struct {
13732                         Type  MinimapType
13733                         Label string
13734                         Size  uint16
13735                         Texture
13736                         Scale uint16
13737                 }))(obj)).Label))[:])
13738                 chk(err)
13739         }
13740         {
13741                 x := (*(*(struct {
13742                         Type  MinimapType
13743                         Label string
13744                         Size  uint16
13745                         Texture
13746                         Scale uint16
13747                 }))(obj)).Size
13748                 write16(w, uint16(x))
13749         }
13750         if err := pcall(func() {
13751                 ((*(*(struct {
13752                         Type  MinimapType
13753                         Label string
13754                         Size  uint16
13755                         Texture
13756                         Scale uint16
13757                 }))(obj)).Texture).serialize(w)
13758         }); err != nil {
13759                 if err == io.EOF {
13760                         chk(io.EOF)
13761                 }
13762                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13763         }
13764         {
13765                 x := (*(*(struct {
13766                         Type  MinimapType
13767                         Label string
13768                         Size  uint16
13769                         Texture
13770                         Scale uint16
13771                 }))(obj)).Scale
13772                 write16(w, uint16(x))
13773         }
13774 }
13775
13776 func (obj *MinimapMode) deserialize(r io.Reader) {
13777         if err := pcall(func() {
13778                 ((*(*(struct {
13779                         Type  MinimapType
13780                         Label string
13781                         Size  uint16
13782                         Texture
13783                         Scale uint16
13784                 }))(obj)).Type).deserialize(r)
13785         }); err != nil {
13786                 if err == io.EOF {
13787                         chk(io.EOF)
13788                 }
13789                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MinimapType", err))
13790         }
13791         var local236 []uint8
13792         var local237 uint16
13793         {
13794                 p := &local237
13795                 *p = read16(r)
13796         }
13797         (local236) = make([]uint8, local237)
13798         {
13799                 _, err := io.ReadFull(r, (local236)[:])
13800                 chk(err)
13801         }
13802         ((*(*(struct {
13803                 Type  MinimapType
13804                 Label string
13805                 Size  uint16
13806                 Texture
13807                 Scale uint16
13808         }))(obj)).Label) = string(local236)
13809         {
13810                 p := &(*(*(struct {
13811                         Type  MinimapType
13812                         Label string
13813                         Size  uint16
13814                         Texture
13815                         Scale uint16
13816                 }))(obj)).Size
13817                 *p = read16(r)
13818         }
13819         if err := pcall(func() {
13820                 ((*(*(struct {
13821                         Type  MinimapType
13822                         Label string
13823                         Size  uint16
13824                         Texture
13825                         Scale uint16
13826                 }))(obj)).Texture).deserialize(r)
13827         }); err != nil {
13828                 if err == io.EOF {
13829                         chk(io.EOF)
13830                 }
13831                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
13832         }
13833         {
13834                 p := &(*(*(struct {
13835                         Type  MinimapType
13836                         Label string
13837                         Size  uint16
13838                         Texture
13839                         Scale uint16
13840                 }))(obj)).Scale
13841                 *p = read16(r)
13842         }
13843 }
13844
13845 func (obj *NodeDef) serialize(w io.Writer) {
13846         if err := pcall(func() {
13847                 ((*(*(struct {
13848                         Param0 Content
13849
13850                         Name   string
13851                         Groups []Group
13852
13853                         P1Type   Param1Type
13854                         P2Type   Param2Type
13855                         DrawType DrawType
13856
13857                         Mesh  string
13858                         Scale float32
13859                         //mt:const uint8(6)
13860                         Tiles        [6]TileDef
13861                         OverlayTiles [6]TileDef
13862                         //mt:const uint8(6)
13863                         SpecialTiles [6]TileDef
13864
13865                         Color   color.NRGBA
13866                         Palette Texture
13867
13868                         Waving       WaveType
13869                         ConnectSides uint8
13870                         ConnectTo    []Content
13871                         InsideTint   color.NRGBA
13872                         Level        uint8 // Must be < 128.
13873
13874                         Translucent bool // Sunlight is scattered and becomes normal light.
13875                         Transparent bool // Sunlight isn't scattered.
13876                         LightSrc    uint8
13877
13878                         GndContent   bool
13879                         Collides     bool
13880                         Pointable    bool
13881                         Diggable     bool
13882                         Climbable    bool
13883                         Replaceable  bool
13884                         OnRightClick bool
13885
13886                         DmgPerSec int32
13887
13888                         LiquidType   LiquidType
13889                         FlowingAlt   string
13890                         SrcAlt       string
13891                         Viscosity    uint8 // 0-7
13892                         LiqRenewable bool
13893                         FlowRange    uint8
13894                         DrownDmg     uint8
13895                         Floodable    bool
13896
13897                         DrawBox, ColBox, SelBox NodeBox
13898
13899                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13900
13901                         LegacyFaceDir bool
13902                         LegacyMounted bool
13903
13904                         DigPredict string
13905
13906                         MaxLvl uint8
13907
13908                         AlphaUse
13909                 }))(obj)).Param0).serialize(w)
13910         }); err != nil {
13911                 if err == io.EOF {
13912                         chk(io.EOF)
13913                 }
13914                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
13915         }
13916         {
13917                 ow := w
13918                 w := new(bytes.Buffer)
13919                 {
13920                         local238 := uint8(13)
13921                         {
13922                                 x := local238
13923                                 write8(w, uint8(x))
13924                         }
13925                 }
13926                 if len(([]byte((*(*(struct {
13927                         Param0 Content
13928
13929                         Name   string
13930                         Groups []Group
13931
13932                         P1Type   Param1Type
13933                         P2Type   Param2Type
13934                         DrawType DrawType
13935
13936                         Mesh  string
13937                         Scale float32
13938                         //mt:const uint8(6)
13939                         Tiles        [6]TileDef
13940                         OverlayTiles [6]TileDef
13941                         //mt:const uint8(6)
13942                         SpecialTiles [6]TileDef
13943
13944                         Color   color.NRGBA
13945                         Palette Texture
13946
13947                         Waving       WaveType
13948                         ConnectSides uint8
13949                         ConnectTo    []Content
13950                         InsideTint   color.NRGBA
13951                         Level        uint8 // Must be < 128.
13952
13953                         Translucent bool // Sunlight is scattered and becomes normal light.
13954                         Transparent bool // Sunlight isn't scattered.
13955                         LightSrc    uint8
13956
13957                         GndContent   bool
13958                         Collides     bool
13959                         Pointable    bool
13960                         Diggable     bool
13961                         Climbable    bool
13962                         Replaceable  bool
13963                         OnRightClick bool
13964
13965                         DmgPerSec int32
13966
13967                         LiquidType   LiquidType
13968                         FlowingAlt   string
13969                         SrcAlt       string
13970                         Viscosity    uint8 // 0-7
13971                         LiqRenewable bool
13972                         FlowRange    uint8
13973                         DrownDmg     uint8
13974                         Floodable    bool
13975
13976                         DrawBox, ColBox, SelBox NodeBox
13977
13978                         FootstepSnd, DiggingSnd, DugSnd SoundDef
13979
13980                         LegacyFaceDir bool
13981                         LegacyMounted bool
13982
13983                         DigPredict string
13984
13985                         MaxLvl uint8
13986
13987                         AlphaUse
13988                 }))(obj)).Name))) > math.MaxUint16 {
13989                         chk(ErrTooLong)
13990                 }
13991                 {
13992                         x := uint16(len(([]byte((*(*(struct {
13993                                 Param0 Content
13994
13995                                 Name   string
13996                                 Groups []Group
13997
13998                                 P1Type   Param1Type
13999                                 P2Type   Param2Type
14000                                 DrawType DrawType
14001
14002                                 Mesh  string
14003                                 Scale float32
14004                                 //mt:const uint8(6)
14005                                 Tiles        [6]TileDef
14006                                 OverlayTiles [6]TileDef
14007                                 //mt:const uint8(6)
14008                                 SpecialTiles [6]TileDef
14009
14010                                 Color   color.NRGBA
14011                                 Palette Texture
14012
14013                                 Waving       WaveType
14014                                 ConnectSides uint8
14015                                 ConnectTo    []Content
14016                                 InsideTint   color.NRGBA
14017                                 Level        uint8 // Must be < 128.
14018
14019                                 Translucent bool // Sunlight is scattered and becomes normal light.
14020                                 Transparent bool // Sunlight isn't scattered.
14021                                 LightSrc    uint8
14022
14023                                 GndContent   bool
14024                                 Collides     bool
14025                                 Pointable    bool
14026                                 Diggable     bool
14027                                 Climbable    bool
14028                                 Replaceable  bool
14029                                 OnRightClick bool
14030
14031                                 DmgPerSec int32
14032
14033                                 LiquidType   LiquidType
14034                                 FlowingAlt   string
14035                                 SrcAlt       string
14036                                 Viscosity    uint8 // 0-7
14037                                 LiqRenewable bool
14038                                 FlowRange    uint8
14039                                 DrownDmg     uint8
14040                                 Floodable    bool
14041
14042                                 DrawBox, ColBox, SelBox NodeBox
14043
14044                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14045
14046                                 LegacyFaceDir bool
14047                                 LegacyMounted bool
14048
14049                                 DigPredict string
14050
14051                                 MaxLvl uint8
14052
14053                                 AlphaUse
14054                         }))(obj)).Name))))
14055                         write16(w, uint16(x))
14056                 }
14057                 {
14058                         _, err := w.Write(([]byte((*(*(struct {
14059                                 Param0 Content
14060
14061                                 Name   string
14062                                 Groups []Group
14063
14064                                 P1Type   Param1Type
14065                                 P2Type   Param2Type
14066                                 DrawType DrawType
14067
14068                                 Mesh  string
14069                                 Scale float32
14070                                 //mt:const uint8(6)
14071                                 Tiles        [6]TileDef
14072                                 OverlayTiles [6]TileDef
14073                                 //mt:const uint8(6)
14074                                 SpecialTiles [6]TileDef
14075
14076                                 Color   color.NRGBA
14077                                 Palette Texture
14078
14079                                 Waving       WaveType
14080                                 ConnectSides uint8
14081                                 ConnectTo    []Content
14082                                 InsideTint   color.NRGBA
14083                                 Level        uint8 // Must be < 128.
14084
14085                                 Translucent bool // Sunlight is scattered and becomes normal light.
14086                                 Transparent bool // Sunlight isn't scattered.
14087                                 LightSrc    uint8
14088
14089                                 GndContent   bool
14090                                 Collides     bool
14091                                 Pointable    bool
14092                                 Diggable     bool
14093                                 Climbable    bool
14094                                 Replaceable  bool
14095                                 OnRightClick bool
14096
14097                                 DmgPerSec int32
14098
14099                                 LiquidType   LiquidType
14100                                 FlowingAlt   string
14101                                 SrcAlt       string
14102                                 Viscosity    uint8 // 0-7
14103                                 LiqRenewable bool
14104                                 FlowRange    uint8
14105                                 DrownDmg     uint8
14106                                 Floodable    bool
14107
14108                                 DrawBox, ColBox, SelBox NodeBox
14109
14110                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14111
14112                                 LegacyFaceDir bool
14113                                 LegacyMounted bool
14114
14115                                 DigPredict string
14116
14117                                 MaxLvl uint8
14118
14119                                 AlphaUse
14120                         }))(obj)).Name))[:])
14121                         chk(err)
14122                 }
14123                 if len(((*(*(struct {
14124                         Param0 Content
14125
14126                         Name   string
14127                         Groups []Group
14128
14129                         P1Type   Param1Type
14130                         P2Type   Param2Type
14131                         DrawType DrawType
14132
14133                         Mesh  string
14134                         Scale float32
14135                         //mt:const uint8(6)
14136                         Tiles        [6]TileDef
14137                         OverlayTiles [6]TileDef
14138                         //mt:const uint8(6)
14139                         SpecialTiles [6]TileDef
14140
14141                         Color   color.NRGBA
14142                         Palette Texture
14143
14144                         Waving       WaveType
14145                         ConnectSides uint8
14146                         ConnectTo    []Content
14147                         InsideTint   color.NRGBA
14148                         Level        uint8 // Must be < 128.
14149
14150                         Translucent bool // Sunlight is scattered and becomes normal light.
14151                         Transparent bool // Sunlight isn't scattered.
14152                         LightSrc    uint8
14153
14154                         GndContent   bool
14155                         Collides     bool
14156                         Pointable    bool
14157                         Diggable     bool
14158                         Climbable    bool
14159                         Replaceable  bool
14160                         OnRightClick bool
14161
14162                         DmgPerSec int32
14163
14164                         LiquidType   LiquidType
14165                         FlowingAlt   string
14166                         SrcAlt       string
14167                         Viscosity    uint8 // 0-7
14168                         LiqRenewable bool
14169                         FlowRange    uint8
14170                         DrownDmg     uint8
14171                         Floodable    bool
14172
14173                         DrawBox, ColBox, SelBox NodeBox
14174
14175                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14176
14177                         LegacyFaceDir bool
14178                         LegacyMounted bool
14179
14180                         DigPredict string
14181
14182                         MaxLvl uint8
14183
14184                         AlphaUse
14185                 }))(obj)).Groups)) > math.MaxUint16 {
14186                         chk(ErrTooLong)
14187                 }
14188                 {
14189                         x := uint16(len(((*(*(struct {
14190                                 Param0 Content
14191
14192                                 Name   string
14193                                 Groups []Group
14194
14195                                 P1Type   Param1Type
14196                                 P2Type   Param2Type
14197                                 DrawType DrawType
14198
14199                                 Mesh  string
14200                                 Scale float32
14201                                 //mt:const uint8(6)
14202                                 Tiles        [6]TileDef
14203                                 OverlayTiles [6]TileDef
14204                                 //mt:const uint8(6)
14205                                 SpecialTiles [6]TileDef
14206
14207                                 Color   color.NRGBA
14208                                 Palette Texture
14209
14210                                 Waving       WaveType
14211                                 ConnectSides uint8
14212                                 ConnectTo    []Content
14213                                 InsideTint   color.NRGBA
14214                                 Level        uint8 // Must be < 128.
14215
14216                                 Translucent bool // Sunlight is scattered and becomes normal light.
14217                                 Transparent bool // Sunlight isn't scattered.
14218                                 LightSrc    uint8
14219
14220                                 GndContent   bool
14221                                 Collides     bool
14222                                 Pointable    bool
14223                                 Diggable     bool
14224                                 Climbable    bool
14225                                 Replaceable  bool
14226                                 OnRightClick bool
14227
14228                                 DmgPerSec int32
14229
14230                                 LiquidType   LiquidType
14231                                 FlowingAlt   string
14232                                 SrcAlt       string
14233                                 Viscosity    uint8 // 0-7
14234                                 LiqRenewable bool
14235                                 FlowRange    uint8
14236                                 DrownDmg     uint8
14237                                 Floodable    bool
14238
14239                                 DrawBox, ColBox, SelBox NodeBox
14240
14241                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14242
14243                                 LegacyFaceDir bool
14244                                 LegacyMounted bool
14245
14246                                 DigPredict string
14247
14248                                 MaxLvl uint8
14249
14250                                 AlphaUse
14251                         }))(obj)).Groups)))
14252                         write16(w, uint16(x))
14253                 }
14254                 for local239 := range (*(*(struct {
14255                         Param0 Content
14256
14257                         Name   string
14258                         Groups []Group
14259
14260                         P1Type   Param1Type
14261                         P2Type   Param2Type
14262                         DrawType DrawType
14263
14264                         Mesh  string
14265                         Scale float32
14266                         //mt:const uint8(6)
14267                         Tiles        [6]TileDef
14268                         OverlayTiles [6]TileDef
14269                         //mt:const uint8(6)
14270                         SpecialTiles [6]TileDef
14271
14272                         Color   color.NRGBA
14273                         Palette Texture
14274
14275                         Waving       WaveType
14276                         ConnectSides uint8
14277                         ConnectTo    []Content
14278                         InsideTint   color.NRGBA
14279                         Level        uint8 // Must be < 128.
14280
14281                         Translucent bool // Sunlight is scattered and becomes normal light.
14282                         Transparent bool // Sunlight isn't scattered.
14283                         LightSrc    uint8
14284
14285                         GndContent   bool
14286                         Collides     bool
14287                         Pointable    bool
14288                         Diggable     bool
14289                         Climbable    bool
14290                         Replaceable  bool
14291                         OnRightClick bool
14292
14293                         DmgPerSec int32
14294
14295                         LiquidType   LiquidType
14296                         FlowingAlt   string
14297                         SrcAlt       string
14298                         Viscosity    uint8 // 0-7
14299                         LiqRenewable bool
14300                         FlowRange    uint8
14301                         DrownDmg     uint8
14302                         Floodable    bool
14303
14304                         DrawBox, ColBox, SelBox NodeBox
14305
14306                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14307
14308                         LegacyFaceDir bool
14309                         LegacyMounted bool
14310
14311                         DigPredict string
14312
14313                         MaxLvl uint8
14314
14315                         AlphaUse
14316                 }))(obj)).Groups {
14317                         if err := pcall(func() {
14318                                 (((*(*(struct {
14319                                         Param0 Content
14320
14321                                         Name   string
14322                                         Groups []Group
14323
14324                                         P1Type   Param1Type
14325                                         P2Type   Param2Type
14326                                         DrawType DrawType
14327
14328                                         Mesh  string
14329                                         Scale float32
14330                                         //mt:const uint8(6)
14331                                         Tiles        [6]TileDef
14332                                         OverlayTiles [6]TileDef
14333                                         //mt:const uint8(6)
14334                                         SpecialTiles [6]TileDef
14335
14336                                         Color   color.NRGBA
14337                                         Palette Texture
14338
14339                                         Waving       WaveType
14340                                         ConnectSides uint8
14341                                         ConnectTo    []Content
14342                                         InsideTint   color.NRGBA
14343                                         Level        uint8 // Must be < 128.
14344
14345                                         Translucent bool // Sunlight is scattered and becomes normal light.
14346                                         Transparent bool // Sunlight isn't scattered.
14347                                         LightSrc    uint8
14348
14349                                         GndContent   bool
14350                                         Collides     bool
14351                                         Pointable    bool
14352                                         Diggable     bool
14353                                         Climbable    bool
14354                                         Replaceable  bool
14355                                         OnRightClick bool
14356
14357                                         DmgPerSec int32
14358
14359                                         LiquidType   LiquidType
14360                                         FlowingAlt   string
14361                                         SrcAlt       string
14362                                         Viscosity    uint8 // 0-7
14363                                         LiqRenewable bool
14364                                         FlowRange    uint8
14365                                         DrownDmg     uint8
14366                                         Floodable    bool
14367
14368                                         DrawBox, ColBox, SelBox NodeBox
14369
14370                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14371
14372                                         LegacyFaceDir bool
14373                                         LegacyMounted bool
14374
14375                                         DigPredict string
14376
14377                                         MaxLvl uint8
14378
14379                                         AlphaUse
14380                                 }))(obj)).Groups)[local239]).serialize(w)
14381                         }); err != nil {
14382                                 if err == io.EOF {
14383                                         chk(io.EOF)
14384                                 }
14385                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
14386                         }
14387                 }
14388                 if err := pcall(func() {
14389                         ((*(*(struct {
14390                                 Param0 Content
14391
14392                                 Name   string
14393                                 Groups []Group
14394
14395                                 P1Type   Param1Type
14396                                 P2Type   Param2Type
14397                                 DrawType DrawType
14398
14399                                 Mesh  string
14400                                 Scale float32
14401                                 //mt:const uint8(6)
14402                                 Tiles        [6]TileDef
14403                                 OverlayTiles [6]TileDef
14404                                 //mt:const uint8(6)
14405                                 SpecialTiles [6]TileDef
14406
14407                                 Color   color.NRGBA
14408                                 Palette Texture
14409
14410                                 Waving       WaveType
14411                                 ConnectSides uint8
14412                                 ConnectTo    []Content
14413                                 InsideTint   color.NRGBA
14414                                 Level        uint8 // Must be < 128.
14415
14416                                 Translucent bool // Sunlight is scattered and becomes normal light.
14417                                 Transparent bool // Sunlight isn't scattered.
14418                                 LightSrc    uint8
14419
14420                                 GndContent   bool
14421                                 Collides     bool
14422                                 Pointable    bool
14423                                 Diggable     bool
14424                                 Climbable    bool
14425                                 Replaceable  bool
14426                                 OnRightClick bool
14427
14428                                 DmgPerSec int32
14429
14430                                 LiquidType   LiquidType
14431                                 FlowingAlt   string
14432                                 SrcAlt       string
14433                                 Viscosity    uint8 // 0-7
14434                                 LiqRenewable bool
14435                                 FlowRange    uint8
14436                                 DrownDmg     uint8
14437                                 Floodable    bool
14438
14439                                 DrawBox, ColBox, SelBox NodeBox
14440
14441                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14442
14443                                 LegacyFaceDir bool
14444                                 LegacyMounted bool
14445
14446                                 DigPredict string
14447
14448                                 MaxLvl uint8
14449
14450                                 AlphaUse
14451                         }))(obj)).P1Type).serialize(w)
14452                 }); err != nil {
14453                         if err == io.EOF {
14454                                 chk(io.EOF)
14455                         }
14456                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param1Type", err))
14457                 }
14458                 if err := pcall(func() {
14459                         ((*(*(struct {
14460                                 Param0 Content
14461
14462                                 Name   string
14463                                 Groups []Group
14464
14465                                 P1Type   Param1Type
14466                                 P2Type   Param2Type
14467                                 DrawType DrawType
14468
14469                                 Mesh  string
14470                                 Scale float32
14471                                 //mt:const uint8(6)
14472                                 Tiles        [6]TileDef
14473                                 OverlayTiles [6]TileDef
14474                                 //mt:const uint8(6)
14475                                 SpecialTiles [6]TileDef
14476
14477                                 Color   color.NRGBA
14478                                 Palette Texture
14479
14480                                 Waving       WaveType
14481                                 ConnectSides uint8
14482                                 ConnectTo    []Content
14483                                 InsideTint   color.NRGBA
14484                                 Level        uint8 // Must be < 128.
14485
14486                                 Translucent bool // Sunlight is scattered and becomes normal light.
14487                                 Transparent bool // Sunlight isn't scattered.
14488                                 LightSrc    uint8
14489
14490                                 GndContent   bool
14491                                 Collides     bool
14492                                 Pointable    bool
14493                                 Diggable     bool
14494                                 Climbable    bool
14495                                 Replaceable  bool
14496                                 OnRightClick bool
14497
14498                                 DmgPerSec int32
14499
14500                                 LiquidType   LiquidType
14501                                 FlowingAlt   string
14502                                 SrcAlt       string
14503                                 Viscosity    uint8 // 0-7
14504                                 LiqRenewable bool
14505                                 FlowRange    uint8
14506                                 DrownDmg     uint8
14507                                 Floodable    bool
14508
14509                                 DrawBox, ColBox, SelBox NodeBox
14510
14511                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14512
14513                                 LegacyFaceDir bool
14514                                 LegacyMounted bool
14515
14516                                 DigPredict string
14517
14518                                 MaxLvl uint8
14519
14520                                 AlphaUse
14521                         }))(obj)).P2Type).serialize(w)
14522                 }); err != nil {
14523                         if err == io.EOF {
14524                                 chk(io.EOF)
14525                         }
14526                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param2Type", err))
14527                 }
14528                 if err := pcall(func() {
14529                         ((*(*(struct {
14530                                 Param0 Content
14531
14532                                 Name   string
14533                                 Groups []Group
14534
14535                                 P1Type   Param1Type
14536                                 P2Type   Param2Type
14537                                 DrawType DrawType
14538
14539                                 Mesh  string
14540                                 Scale float32
14541                                 //mt:const uint8(6)
14542                                 Tiles        [6]TileDef
14543                                 OverlayTiles [6]TileDef
14544                                 //mt:const uint8(6)
14545                                 SpecialTiles [6]TileDef
14546
14547                                 Color   color.NRGBA
14548                                 Palette Texture
14549
14550                                 Waving       WaveType
14551                                 ConnectSides uint8
14552                                 ConnectTo    []Content
14553                                 InsideTint   color.NRGBA
14554                                 Level        uint8 // Must be < 128.
14555
14556                                 Translucent bool // Sunlight is scattered and becomes normal light.
14557                                 Transparent bool // Sunlight isn't scattered.
14558                                 LightSrc    uint8
14559
14560                                 GndContent   bool
14561                                 Collides     bool
14562                                 Pointable    bool
14563                                 Diggable     bool
14564                                 Climbable    bool
14565                                 Replaceable  bool
14566                                 OnRightClick bool
14567
14568                                 DmgPerSec int32
14569
14570                                 LiquidType   LiquidType
14571                                 FlowingAlt   string
14572                                 SrcAlt       string
14573                                 Viscosity    uint8 // 0-7
14574                                 LiqRenewable bool
14575                                 FlowRange    uint8
14576                                 DrownDmg     uint8
14577                                 Floodable    bool
14578
14579                                 DrawBox, ColBox, SelBox NodeBox
14580
14581                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14582
14583                                 LegacyFaceDir bool
14584                                 LegacyMounted bool
14585
14586                                 DigPredict string
14587
14588                                 MaxLvl uint8
14589
14590                                 AlphaUse
14591                         }))(obj)).DrawType).serialize(w)
14592                 }); err != nil {
14593                         if err == io.EOF {
14594                                 chk(io.EOF)
14595                         }
14596                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DrawType", err))
14597                 }
14598                 if len(([]byte((*(*(struct {
14599                         Param0 Content
14600
14601                         Name   string
14602                         Groups []Group
14603
14604                         P1Type   Param1Type
14605                         P2Type   Param2Type
14606                         DrawType DrawType
14607
14608                         Mesh  string
14609                         Scale float32
14610                         //mt:const uint8(6)
14611                         Tiles        [6]TileDef
14612                         OverlayTiles [6]TileDef
14613                         //mt:const uint8(6)
14614                         SpecialTiles [6]TileDef
14615
14616                         Color   color.NRGBA
14617                         Palette Texture
14618
14619                         Waving       WaveType
14620                         ConnectSides uint8
14621                         ConnectTo    []Content
14622                         InsideTint   color.NRGBA
14623                         Level        uint8 // Must be < 128.
14624
14625                         Translucent bool // Sunlight is scattered and becomes normal light.
14626                         Transparent bool // Sunlight isn't scattered.
14627                         LightSrc    uint8
14628
14629                         GndContent   bool
14630                         Collides     bool
14631                         Pointable    bool
14632                         Diggable     bool
14633                         Climbable    bool
14634                         Replaceable  bool
14635                         OnRightClick bool
14636
14637                         DmgPerSec int32
14638
14639                         LiquidType   LiquidType
14640                         FlowingAlt   string
14641                         SrcAlt       string
14642                         Viscosity    uint8 // 0-7
14643                         LiqRenewable bool
14644                         FlowRange    uint8
14645                         DrownDmg     uint8
14646                         Floodable    bool
14647
14648                         DrawBox, ColBox, SelBox NodeBox
14649
14650                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14651
14652                         LegacyFaceDir bool
14653                         LegacyMounted bool
14654
14655                         DigPredict string
14656
14657                         MaxLvl uint8
14658
14659                         AlphaUse
14660                 }))(obj)).Mesh))) > math.MaxUint16 {
14661                         chk(ErrTooLong)
14662                 }
14663                 {
14664                         x := uint16(len(([]byte((*(*(struct {
14665                                 Param0 Content
14666
14667                                 Name   string
14668                                 Groups []Group
14669
14670                                 P1Type   Param1Type
14671                                 P2Type   Param2Type
14672                                 DrawType DrawType
14673
14674                                 Mesh  string
14675                                 Scale float32
14676                                 //mt:const uint8(6)
14677                                 Tiles        [6]TileDef
14678                                 OverlayTiles [6]TileDef
14679                                 //mt:const uint8(6)
14680                                 SpecialTiles [6]TileDef
14681
14682                                 Color   color.NRGBA
14683                                 Palette Texture
14684
14685                                 Waving       WaveType
14686                                 ConnectSides uint8
14687                                 ConnectTo    []Content
14688                                 InsideTint   color.NRGBA
14689                                 Level        uint8 // Must be < 128.
14690
14691                                 Translucent bool // Sunlight is scattered and becomes normal light.
14692                                 Transparent bool // Sunlight isn't scattered.
14693                                 LightSrc    uint8
14694
14695                                 GndContent   bool
14696                                 Collides     bool
14697                                 Pointable    bool
14698                                 Diggable     bool
14699                                 Climbable    bool
14700                                 Replaceable  bool
14701                                 OnRightClick bool
14702
14703                                 DmgPerSec int32
14704
14705                                 LiquidType   LiquidType
14706                                 FlowingAlt   string
14707                                 SrcAlt       string
14708                                 Viscosity    uint8 // 0-7
14709                                 LiqRenewable bool
14710                                 FlowRange    uint8
14711                                 DrownDmg     uint8
14712                                 Floodable    bool
14713
14714                                 DrawBox, ColBox, SelBox NodeBox
14715
14716                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14717
14718                                 LegacyFaceDir bool
14719                                 LegacyMounted bool
14720
14721                                 DigPredict string
14722
14723                                 MaxLvl uint8
14724
14725                                 AlphaUse
14726                         }))(obj)).Mesh))))
14727                         write16(w, uint16(x))
14728                 }
14729                 {
14730                         _, err := w.Write(([]byte((*(*(struct {
14731                                 Param0 Content
14732
14733                                 Name   string
14734                                 Groups []Group
14735
14736                                 P1Type   Param1Type
14737                                 P2Type   Param2Type
14738                                 DrawType DrawType
14739
14740                                 Mesh  string
14741                                 Scale float32
14742                                 //mt:const uint8(6)
14743                                 Tiles        [6]TileDef
14744                                 OverlayTiles [6]TileDef
14745                                 //mt:const uint8(6)
14746                                 SpecialTiles [6]TileDef
14747
14748                                 Color   color.NRGBA
14749                                 Palette Texture
14750
14751                                 Waving       WaveType
14752                                 ConnectSides uint8
14753                                 ConnectTo    []Content
14754                                 InsideTint   color.NRGBA
14755                                 Level        uint8 // Must be < 128.
14756
14757                                 Translucent bool // Sunlight is scattered and becomes normal light.
14758                                 Transparent bool // Sunlight isn't scattered.
14759                                 LightSrc    uint8
14760
14761                                 GndContent   bool
14762                                 Collides     bool
14763                                 Pointable    bool
14764                                 Diggable     bool
14765                                 Climbable    bool
14766                                 Replaceable  bool
14767                                 OnRightClick bool
14768
14769                                 DmgPerSec int32
14770
14771                                 LiquidType   LiquidType
14772                                 FlowingAlt   string
14773                                 SrcAlt       string
14774                                 Viscosity    uint8 // 0-7
14775                                 LiqRenewable bool
14776                                 FlowRange    uint8
14777                                 DrownDmg     uint8
14778                                 Floodable    bool
14779
14780                                 DrawBox, ColBox, SelBox NodeBox
14781
14782                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14783
14784                                 LegacyFaceDir bool
14785                                 LegacyMounted bool
14786
14787                                 DigPredict string
14788
14789                                 MaxLvl uint8
14790
14791                                 AlphaUse
14792                         }))(obj)).Mesh))[:])
14793                         chk(err)
14794                 }
14795                 {
14796                         x := (*(*(struct {
14797                                 Param0 Content
14798
14799                                 Name   string
14800                                 Groups []Group
14801
14802                                 P1Type   Param1Type
14803                                 P2Type   Param2Type
14804                                 DrawType DrawType
14805
14806                                 Mesh  string
14807                                 Scale float32
14808                                 //mt:const uint8(6)
14809                                 Tiles        [6]TileDef
14810                                 OverlayTiles [6]TileDef
14811                                 //mt:const uint8(6)
14812                                 SpecialTiles [6]TileDef
14813
14814                                 Color   color.NRGBA
14815                                 Palette Texture
14816
14817                                 Waving       WaveType
14818                                 ConnectSides uint8
14819                                 ConnectTo    []Content
14820                                 InsideTint   color.NRGBA
14821                                 Level        uint8 // Must be < 128.
14822
14823                                 Translucent bool // Sunlight is scattered and becomes normal light.
14824                                 Transparent bool // Sunlight isn't scattered.
14825                                 LightSrc    uint8
14826
14827                                 GndContent   bool
14828                                 Collides     bool
14829                                 Pointable    bool
14830                                 Diggable     bool
14831                                 Climbable    bool
14832                                 Replaceable  bool
14833                                 OnRightClick bool
14834
14835                                 DmgPerSec int32
14836
14837                                 LiquidType   LiquidType
14838                                 FlowingAlt   string
14839                                 SrcAlt       string
14840                                 Viscosity    uint8 // 0-7
14841                                 LiqRenewable bool
14842                                 FlowRange    uint8
14843                                 DrownDmg     uint8
14844                                 Floodable    bool
14845
14846                                 DrawBox, ColBox, SelBox NodeBox
14847
14848                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14849
14850                                 LegacyFaceDir bool
14851                                 LegacyMounted bool
14852
14853                                 DigPredict string
14854
14855                                 MaxLvl uint8
14856
14857                                 AlphaUse
14858                         }))(obj)).Scale
14859                         write32(w, math.Float32bits(x))
14860                 }
14861                 {
14862                         local240 := uint8(6)
14863                         {
14864                                 x := local240
14865                                 write8(w, uint8(x))
14866                         }
14867                 }
14868                 for local241 := range (*(*(struct {
14869                         Param0 Content
14870
14871                         Name   string
14872                         Groups []Group
14873
14874                         P1Type   Param1Type
14875                         P2Type   Param2Type
14876                         DrawType DrawType
14877
14878                         Mesh  string
14879                         Scale float32
14880                         //mt:const uint8(6)
14881                         Tiles        [6]TileDef
14882                         OverlayTiles [6]TileDef
14883                         //mt:const uint8(6)
14884                         SpecialTiles [6]TileDef
14885
14886                         Color   color.NRGBA
14887                         Palette Texture
14888
14889                         Waving       WaveType
14890                         ConnectSides uint8
14891                         ConnectTo    []Content
14892                         InsideTint   color.NRGBA
14893                         Level        uint8 // Must be < 128.
14894
14895                         Translucent bool // Sunlight is scattered and becomes normal light.
14896                         Transparent bool // Sunlight isn't scattered.
14897                         LightSrc    uint8
14898
14899                         GndContent   bool
14900                         Collides     bool
14901                         Pointable    bool
14902                         Diggable     bool
14903                         Climbable    bool
14904                         Replaceable  bool
14905                         OnRightClick bool
14906
14907                         DmgPerSec int32
14908
14909                         LiquidType   LiquidType
14910                         FlowingAlt   string
14911                         SrcAlt       string
14912                         Viscosity    uint8 // 0-7
14913                         LiqRenewable bool
14914                         FlowRange    uint8
14915                         DrownDmg     uint8
14916                         Floodable    bool
14917
14918                         DrawBox, ColBox, SelBox NodeBox
14919
14920                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14921
14922                         LegacyFaceDir bool
14923                         LegacyMounted bool
14924
14925                         DigPredict string
14926
14927                         MaxLvl uint8
14928
14929                         AlphaUse
14930                 }))(obj)).Tiles {
14931                         if err := pcall(func() {
14932                                 (((*(*(struct {
14933                                         Param0 Content
14934
14935                                         Name   string
14936                                         Groups []Group
14937
14938                                         P1Type   Param1Type
14939                                         P2Type   Param2Type
14940                                         DrawType DrawType
14941
14942                                         Mesh  string
14943                                         Scale float32
14944                                         //mt:const uint8(6)
14945                                         Tiles        [6]TileDef
14946                                         OverlayTiles [6]TileDef
14947                                         //mt:const uint8(6)
14948                                         SpecialTiles [6]TileDef
14949
14950                                         Color   color.NRGBA
14951                                         Palette Texture
14952
14953                                         Waving       WaveType
14954                                         ConnectSides uint8
14955                                         ConnectTo    []Content
14956                                         InsideTint   color.NRGBA
14957                                         Level        uint8 // Must be < 128.
14958
14959                                         Translucent bool // Sunlight is scattered and becomes normal light.
14960                                         Transparent bool // Sunlight isn't scattered.
14961                                         LightSrc    uint8
14962
14963                                         GndContent   bool
14964                                         Collides     bool
14965                                         Pointable    bool
14966                                         Diggable     bool
14967                                         Climbable    bool
14968                                         Replaceable  bool
14969                                         OnRightClick bool
14970
14971                                         DmgPerSec int32
14972
14973                                         LiquidType   LiquidType
14974                                         FlowingAlt   string
14975                                         SrcAlt       string
14976                                         Viscosity    uint8 // 0-7
14977                                         LiqRenewable bool
14978                                         FlowRange    uint8
14979                                         DrownDmg     uint8
14980                                         Floodable    bool
14981
14982                                         DrawBox, ColBox, SelBox NodeBox
14983
14984                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14985
14986                                         LegacyFaceDir bool
14987                                         LegacyMounted bool
14988
14989                                         DigPredict string
14990
14991                                         MaxLvl uint8
14992
14993                                         AlphaUse
14994                                 }))(obj)).Tiles)[local241]).serialize(w)
14995                         }); err != nil {
14996                                 if err == io.EOF {
14997                                         chk(io.EOF)
14998                                 }
14999                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
15000                         }
15001                 }
15002                 for local242 := range (*(*(struct {
15003                         Param0 Content
15004
15005                         Name   string
15006                         Groups []Group
15007
15008                         P1Type   Param1Type
15009                         P2Type   Param2Type
15010                         DrawType DrawType
15011
15012                         Mesh  string
15013                         Scale float32
15014                         //mt:const uint8(6)
15015                         Tiles        [6]TileDef
15016                         OverlayTiles [6]TileDef
15017                         //mt:const uint8(6)
15018                         SpecialTiles [6]TileDef
15019
15020                         Color   color.NRGBA
15021                         Palette Texture
15022
15023                         Waving       WaveType
15024                         ConnectSides uint8
15025                         ConnectTo    []Content
15026                         InsideTint   color.NRGBA
15027                         Level        uint8 // Must be < 128.
15028
15029                         Translucent bool // Sunlight is scattered and becomes normal light.
15030                         Transparent bool // Sunlight isn't scattered.
15031                         LightSrc    uint8
15032
15033                         GndContent   bool
15034                         Collides     bool
15035                         Pointable    bool
15036                         Diggable     bool
15037                         Climbable    bool
15038                         Replaceable  bool
15039                         OnRightClick bool
15040
15041                         DmgPerSec int32
15042
15043                         LiquidType   LiquidType
15044                         FlowingAlt   string
15045                         SrcAlt       string
15046                         Viscosity    uint8 // 0-7
15047                         LiqRenewable bool
15048                         FlowRange    uint8
15049                         DrownDmg     uint8
15050                         Floodable    bool
15051
15052                         DrawBox, ColBox, SelBox NodeBox
15053
15054                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15055
15056                         LegacyFaceDir bool
15057                         LegacyMounted bool
15058
15059                         DigPredict string
15060
15061                         MaxLvl uint8
15062
15063                         AlphaUse
15064                 }))(obj)).OverlayTiles {
15065                         if err := pcall(func() {
15066                                 (((*(*(struct {
15067                                         Param0 Content
15068
15069                                         Name   string
15070                                         Groups []Group
15071
15072                                         P1Type   Param1Type
15073                                         P2Type   Param2Type
15074                                         DrawType DrawType
15075
15076                                         Mesh  string
15077                                         Scale float32
15078                                         //mt:const uint8(6)
15079                                         Tiles        [6]TileDef
15080                                         OverlayTiles [6]TileDef
15081                                         //mt:const uint8(6)
15082                                         SpecialTiles [6]TileDef
15083
15084                                         Color   color.NRGBA
15085                                         Palette Texture
15086
15087                                         Waving       WaveType
15088                                         ConnectSides uint8
15089                                         ConnectTo    []Content
15090                                         InsideTint   color.NRGBA
15091                                         Level        uint8 // Must be < 128.
15092
15093                                         Translucent bool // Sunlight is scattered and becomes normal light.
15094                                         Transparent bool // Sunlight isn't scattered.
15095                                         LightSrc    uint8
15096
15097                                         GndContent   bool
15098                                         Collides     bool
15099                                         Pointable    bool
15100                                         Diggable     bool
15101                                         Climbable    bool
15102                                         Replaceable  bool
15103                                         OnRightClick bool
15104
15105                                         DmgPerSec int32
15106
15107                                         LiquidType   LiquidType
15108                                         FlowingAlt   string
15109                                         SrcAlt       string
15110                                         Viscosity    uint8 // 0-7
15111                                         LiqRenewable bool
15112                                         FlowRange    uint8
15113                                         DrownDmg     uint8
15114                                         Floodable    bool
15115
15116                                         DrawBox, ColBox, SelBox NodeBox
15117
15118                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15119
15120                                         LegacyFaceDir bool
15121                                         LegacyMounted bool
15122
15123                                         DigPredict string
15124
15125                                         MaxLvl uint8
15126
15127                                         AlphaUse
15128                                 }))(obj)).OverlayTiles)[local242]).serialize(w)
15129                         }); err != nil {
15130                                 if err == io.EOF {
15131                                         chk(io.EOF)
15132                                 }
15133                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
15134                         }
15135                 }
15136                 {
15137                         local243 := uint8(6)
15138                         {
15139                                 x := local243
15140                                 write8(w, uint8(x))
15141                         }
15142                 }
15143                 for local244 := range (*(*(struct {
15144                         Param0 Content
15145
15146                         Name   string
15147                         Groups []Group
15148
15149                         P1Type   Param1Type
15150                         P2Type   Param2Type
15151                         DrawType DrawType
15152
15153                         Mesh  string
15154                         Scale float32
15155                         //mt:const uint8(6)
15156                         Tiles        [6]TileDef
15157                         OverlayTiles [6]TileDef
15158                         //mt:const uint8(6)
15159                         SpecialTiles [6]TileDef
15160
15161                         Color   color.NRGBA
15162                         Palette Texture
15163
15164                         Waving       WaveType
15165                         ConnectSides uint8
15166                         ConnectTo    []Content
15167                         InsideTint   color.NRGBA
15168                         Level        uint8 // Must be < 128.
15169
15170                         Translucent bool // Sunlight is scattered and becomes normal light.
15171                         Transparent bool // Sunlight isn't scattered.
15172                         LightSrc    uint8
15173
15174                         GndContent   bool
15175                         Collides     bool
15176                         Pointable    bool
15177                         Diggable     bool
15178                         Climbable    bool
15179                         Replaceable  bool
15180                         OnRightClick bool
15181
15182                         DmgPerSec int32
15183
15184                         LiquidType   LiquidType
15185                         FlowingAlt   string
15186                         SrcAlt       string
15187                         Viscosity    uint8 // 0-7
15188                         LiqRenewable bool
15189                         FlowRange    uint8
15190                         DrownDmg     uint8
15191                         Floodable    bool
15192
15193                         DrawBox, ColBox, SelBox NodeBox
15194
15195                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15196
15197                         LegacyFaceDir bool
15198                         LegacyMounted bool
15199
15200                         DigPredict string
15201
15202                         MaxLvl uint8
15203
15204                         AlphaUse
15205                 }))(obj)).SpecialTiles {
15206                         if err := pcall(func() {
15207                                 (((*(*(struct {
15208                                         Param0 Content
15209
15210                                         Name   string
15211                                         Groups []Group
15212
15213                                         P1Type   Param1Type
15214                                         P2Type   Param2Type
15215                                         DrawType DrawType
15216
15217                                         Mesh  string
15218                                         Scale float32
15219                                         //mt:const uint8(6)
15220                                         Tiles        [6]TileDef
15221                                         OverlayTiles [6]TileDef
15222                                         //mt:const uint8(6)
15223                                         SpecialTiles [6]TileDef
15224
15225                                         Color   color.NRGBA
15226                                         Palette Texture
15227
15228                                         Waving       WaveType
15229                                         ConnectSides uint8
15230                                         ConnectTo    []Content
15231                                         InsideTint   color.NRGBA
15232                                         Level        uint8 // Must be < 128.
15233
15234                                         Translucent bool // Sunlight is scattered and becomes normal light.
15235                                         Transparent bool // Sunlight isn't scattered.
15236                                         LightSrc    uint8
15237
15238                                         GndContent   bool
15239                                         Collides     bool
15240                                         Pointable    bool
15241                                         Diggable     bool
15242                                         Climbable    bool
15243                                         Replaceable  bool
15244                                         OnRightClick bool
15245
15246                                         DmgPerSec int32
15247
15248                                         LiquidType   LiquidType
15249                                         FlowingAlt   string
15250                                         SrcAlt       string
15251                                         Viscosity    uint8 // 0-7
15252                                         LiqRenewable bool
15253                                         FlowRange    uint8
15254                                         DrownDmg     uint8
15255                                         Floodable    bool
15256
15257                                         DrawBox, ColBox, SelBox NodeBox
15258
15259                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15260
15261                                         LegacyFaceDir bool
15262                                         LegacyMounted bool
15263
15264                                         DigPredict string
15265
15266                                         MaxLvl uint8
15267
15268                                         AlphaUse
15269                                 }))(obj)).SpecialTiles)[local244]).serialize(w)
15270                         }); err != nil {
15271                                 if err == io.EOF {
15272                                         chk(io.EOF)
15273                                 }
15274                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
15275                         }
15276                 }
15277                 {
15278                         x := (*(*(struct {
15279                                 Param0 Content
15280
15281                                 Name   string
15282                                 Groups []Group
15283
15284                                 P1Type   Param1Type
15285                                 P2Type   Param2Type
15286                                 DrawType DrawType
15287
15288                                 Mesh  string
15289                                 Scale float32
15290                                 //mt:const uint8(6)
15291                                 Tiles        [6]TileDef
15292                                 OverlayTiles [6]TileDef
15293                                 //mt:const uint8(6)
15294                                 SpecialTiles [6]TileDef
15295
15296                                 Color   color.NRGBA
15297                                 Palette Texture
15298
15299                                 Waving       WaveType
15300                                 ConnectSides uint8
15301                                 ConnectTo    []Content
15302                                 InsideTint   color.NRGBA
15303                                 Level        uint8 // Must be < 128.
15304
15305                                 Translucent bool // Sunlight is scattered and becomes normal light.
15306                                 Transparent bool // Sunlight isn't scattered.
15307                                 LightSrc    uint8
15308
15309                                 GndContent   bool
15310                                 Collides     bool
15311                                 Pointable    bool
15312                                 Diggable     bool
15313                                 Climbable    bool
15314                                 Replaceable  bool
15315                                 OnRightClick bool
15316
15317                                 DmgPerSec int32
15318
15319                                 LiquidType   LiquidType
15320                                 FlowingAlt   string
15321                                 SrcAlt       string
15322                                 Viscosity    uint8 // 0-7
15323                                 LiqRenewable bool
15324                                 FlowRange    uint8
15325                                 DrownDmg     uint8
15326                                 Floodable    bool
15327
15328                                 DrawBox, ColBox, SelBox NodeBox
15329
15330                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15331
15332                                 LegacyFaceDir bool
15333                                 LegacyMounted bool
15334
15335                                 DigPredict string
15336
15337                                 MaxLvl uint8
15338
15339                                 AlphaUse
15340                         }))(obj)).Color
15341                         w.Write([]byte{x.A, x.R, x.G, x.B})
15342
15343                 }
15344                 if err := pcall(func() {
15345                         ((*(*(struct {
15346                                 Param0 Content
15347
15348                                 Name   string
15349                                 Groups []Group
15350
15351                                 P1Type   Param1Type
15352                                 P2Type   Param2Type
15353                                 DrawType DrawType
15354
15355                                 Mesh  string
15356                                 Scale float32
15357                                 //mt:const uint8(6)
15358                                 Tiles        [6]TileDef
15359                                 OverlayTiles [6]TileDef
15360                                 //mt:const uint8(6)
15361                                 SpecialTiles [6]TileDef
15362
15363                                 Color   color.NRGBA
15364                                 Palette Texture
15365
15366                                 Waving       WaveType
15367                                 ConnectSides uint8
15368                                 ConnectTo    []Content
15369                                 InsideTint   color.NRGBA
15370                                 Level        uint8 // Must be < 128.
15371
15372                                 Translucent bool // Sunlight is scattered and becomes normal light.
15373                                 Transparent bool // Sunlight isn't scattered.
15374                                 LightSrc    uint8
15375
15376                                 GndContent   bool
15377                                 Collides     bool
15378                                 Pointable    bool
15379                                 Diggable     bool
15380                                 Climbable    bool
15381                                 Replaceable  bool
15382                                 OnRightClick bool
15383
15384                                 DmgPerSec int32
15385
15386                                 LiquidType   LiquidType
15387                                 FlowingAlt   string
15388                                 SrcAlt       string
15389                                 Viscosity    uint8 // 0-7
15390                                 LiqRenewable bool
15391                                 FlowRange    uint8
15392                                 DrownDmg     uint8
15393                                 Floodable    bool
15394
15395                                 DrawBox, ColBox, SelBox NodeBox
15396
15397                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15398
15399                                 LegacyFaceDir bool
15400                                 LegacyMounted bool
15401
15402                                 DigPredict string
15403
15404                                 MaxLvl uint8
15405
15406                                 AlphaUse
15407                         }))(obj)).Palette).serialize(w)
15408                 }); err != nil {
15409                         if err == io.EOF {
15410                                 chk(io.EOF)
15411                         }
15412                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
15413                 }
15414                 if err := pcall(func() {
15415                         ((*(*(struct {
15416                                 Param0 Content
15417
15418                                 Name   string
15419                                 Groups []Group
15420
15421                                 P1Type   Param1Type
15422                                 P2Type   Param2Type
15423                                 DrawType DrawType
15424
15425                                 Mesh  string
15426                                 Scale float32
15427                                 //mt:const uint8(6)
15428                                 Tiles        [6]TileDef
15429                                 OverlayTiles [6]TileDef
15430                                 //mt:const uint8(6)
15431                                 SpecialTiles [6]TileDef
15432
15433                                 Color   color.NRGBA
15434                                 Palette Texture
15435
15436                                 Waving       WaveType
15437                                 ConnectSides uint8
15438                                 ConnectTo    []Content
15439                                 InsideTint   color.NRGBA
15440                                 Level        uint8 // Must be < 128.
15441
15442                                 Translucent bool // Sunlight is scattered and becomes normal light.
15443                                 Transparent bool // Sunlight isn't scattered.
15444                                 LightSrc    uint8
15445
15446                                 GndContent   bool
15447                                 Collides     bool
15448                                 Pointable    bool
15449                                 Diggable     bool
15450                                 Climbable    bool
15451                                 Replaceable  bool
15452                                 OnRightClick bool
15453
15454                                 DmgPerSec int32
15455
15456                                 LiquidType   LiquidType
15457                                 FlowingAlt   string
15458                                 SrcAlt       string
15459                                 Viscosity    uint8 // 0-7
15460                                 LiqRenewable bool
15461                                 FlowRange    uint8
15462                                 DrownDmg     uint8
15463                                 Floodable    bool
15464
15465                                 DrawBox, ColBox, SelBox NodeBox
15466
15467                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15468
15469                                 LegacyFaceDir bool
15470                                 LegacyMounted bool
15471
15472                                 DigPredict string
15473
15474                                 MaxLvl uint8
15475
15476                                 AlphaUse
15477                         }))(obj)).Waving).serialize(w)
15478                 }); err != nil {
15479                         if err == io.EOF {
15480                                 chk(io.EOF)
15481                         }
15482                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.WaveType", err))
15483                 }
15484                 {
15485                         x := (*(*(struct {
15486                                 Param0 Content
15487
15488                                 Name   string
15489                                 Groups []Group
15490
15491                                 P1Type   Param1Type
15492                                 P2Type   Param2Type
15493                                 DrawType DrawType
15494
15495                                 Mesh  string
15496                                 Scale float32
15497                                 //mt:const uint8(6)
15498                                 Tiles        [6]TileDef
15499                                 OverlayTiles [6]TileDef
15500                                 //mt:const uint8(6)
15501                                 SpecialTiles [6]TileDef
15502
15503                                 Color   color.NRGBA
15504                                 Palette Texture
15505
15506                                 Waving       WaveType
15507                                 ConnectSides uint8
15508                                 ConnectTo    []Content
15509                                 InsideTint   color.NRGBA
15510                                 Level        uint8 // Must be < 128.
15511
15512                                 Translucent bool // Sunlight is scattered and becomes normal light.
15513                                 Transparent bool // Sunlight isn't scattered.
15514                                 LightSrc    uint8
15515
15516                                 GndContent   bool
15517                                 Collides     bool
15518                                 Pointable    bool
15519                                 Diggable     bool
15520                                 Climbable    bool
15521                                 Replaceable  bool
15522                                 OnRightClick bool
15523
15524                                 DmgPerSec int32
15525
15526                                 LiquidType   LiquidType
15527                                 FlowingAlt   string
15528                                 SrcAlt       string
15529                                 Viscosity    uint8 // 0-7
15530                                 LiqRenewable bool
15531                                 FlowRange    uint8
15532                                 DrownDmg     uint8
15533                                 Floodable    bool
15534
15535                                 DrawBox, ColBox, SelBox NodeBox
15536
15537                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15538
15539                                 LegacyFaceDir bool
15540                                 LegacyMounted bool
15541
15542                                 DigPredict string
15543
15544                                 MaxLvl uint8
15545
15546                                 AlphaUse
15547                         }))(obj)).ConnectSides
15548                         write8(w, uint8(x))
15549                 }
15550                 if len(((*(*(struct {
15551                         Param0 Content
15552
15553                         Name   string
15554                         Groups []Group
15555
15556                         P1Type   Param1Type
15557                         P2Type   Param2Type
15558                         DrawType DrawType
15559
15560                         Mesh  string
15561                         Scale float32
15562                         //mt:const uint8(6)
15563                         Tiles        [6]TileDef
15564                         OverlayTiles [6]TileDef
15565                         //mt:const uint8(6)
15566                         SpecialTiles [6]TileDef
15567
15568                         Color   color.NRGBA
15569                         Palette Texture
15570
15571                         Waving       WaveType
15572                         ConnectSides uint8
15573                         ConnectTo    []Content
15574                         InsideTint   color.NRGBA
15575                         Level        uint8 // Must be < 128.
15576
15577                         Translucent bool // Sunlight is scattered and becomes normal light.
15578                         Transparent bool // Sunlight isn't scattered.
15579                         LightSrc    uint8
15580
15581                         GndContent   bool
15582                         Collides     bool
15583                         Pointable    bool
15584                         Diggable     bool
15585                         Climbable    bool
15586                         Replaceable  bool
15587                         OnRightClick bool
15588
15589                         DmgPerSec int32
15590
15591                         LiquidType   LiquidType
15592                         FlowingAlt   string
15593                         SrcAlt       string
15594                         Viscosity    uint8 // 0-7
15595                         LiqRenewable bool
15596                         FlowRange    uint8
15597                         DrownDmg     uint8
15598                         Floodable    bool
15599
15600                         DrawBox, ColBox, SelBox NodeBox
15601
15602                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15603
15604                         LegacyFaceDir bool
15605                         LegacyMounted bool
15606
15607                         DigPredict string
15608
15609                         MaxLvl uint8
15610
15611                         AlphaUse
15612                 }))(obj)).ConnectTo)) > math.MaxUint16 {
15613                         chk(ErrTooLong)
15614                 }
15615                 {
15616                         x := uint16(len(((*(*(struct {
15617                                 Param0 Content
15618
15619                                 Name   string
15620                                 Groups []Group
15621
15622                                 P1Type   Param1Type
15623                                 P2Type   Param2Type
15624                                 DrawType DrawType
15625
15626                                 Mesh  string
15627                                 Scale float32
15628                                 //mt:const uint8(6)
15629                                 Tiles        [6]TileDef
15630                                 OverlayTiles [6]TileDef
15631                                 //mt:const uint8(6)
15632                                 SpecialTiles [6]TileDef
15633
15634                                 Color   color.NRGBA
15635                                 Palette Texture
15636
15637                                 Waving       WaveType
15638                                 ConnectSides uint8
15639                                 ConnectTo    []Content
15640                                 InsideTint   color.NRGBA
15641                                 Level        uint8 // Must be < 128.
15642
15643                                 Translucent bool // Sunlight is scattered and becomes normal light.
15644                                 Transparent bool // Sunlight isn't scattered.
15645                                 LightSrc    uint8
15646
15647                                 GndContent   bool
15648                                 Collides     bool
15649                                 Pointable    bool
15650                                 Diggable     bool
15651                                 Climbable    bool
15652                                 Replaceable  bool
15653                                 OnRightClick bool
15654
15655                                 DmgPerSec int32
15656
15657                                 LiquidType   LiquidType
15658                                 FlowingAlt   string
15659                                 SrcAlt       string
15660                                 Viscosity    uint8 // 0-7
15661                                 LiqRenewable bool
15662                                 FlowRange    uint8
15663                                 DrownDmg     uint8
15664                                 Floodable    bool
15665
15666                                 DrawBox, ColBox, SelBox NodeBox
15667
15668                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15669
15670                                 LegacyFaceDir bool
15671                                 LegacyMounted bool
15672
15673                                 DigPredict string
15674
15675                                 MaxLvl uint8
15676
15677                                 AlphaUse
15678                         }))(obj)).ConnectTo)))
15679                         write16(w, uint16(x))
15680                 }
15681                 for local245 := range (*(*(struct {
15682                         Param0 Content
15683
15684                         Name   string
15685                         Groups []Group
15686
15687                         P1Type   Param1Type
15688                         P2Type   Param2Type
15689                         DrawType DrawType
15690
15691                         Mesh  string
15692                         Scale float32
15693                         //mt:const uint8(6)
15694                         Tiles        [6]TileDef
15695                         OverlayTiles [6]TileDef
15696                         //mt:const uint8(6)
15697                         SpecialTiles [6]TileDef
15698
15699                         Color   color.NRGBA
15700                         Palette Texture
15701
15702                         Waving       WaveType
15703                         ConnectSides uint8
15704                         ConnectTo    []Content
15705                         InsideTint   color.NRGBA
15706                         Level        uint8 // Must be < 128.
15707
15708                         Translucent bool // Sunlight is scattered and becomes normal light.
15709                         Transparent bool // Sunlight isn't scattered.
15710                         LightSrc    uint8
15711
15712                         GndContent   bool
15713                         Collides     bool
15714                         Pointable    bool
15715                         Diggable     bool
15716                         Climbable    bool
15717                         Replaceable  bool
15718                         OnRightClick bool
15719
15720                         DmgPerSec int32
15721
15722                         LiquidType   LiquidType
15723                         FlowingAlt   string
15724                         SrcAlt       string
15725                         Viscosity    uint8 // 0-7
15726                         LiqRenewable bool
15727                         FlowRange    uint8
15728                         DrownDmg     uint8
15729                         Floodable    bool
15730
15731                         DrawBox, ColBox, SelBox NodeBox
15732
15733                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15734
15735                         LegacyFaceDir bool
15736                         LegacyMounted bool
15737
15738                         DigPredict string
15739
15740                         MaxLvl uint8
15741
15742                         AlphaUse
15743                 }))(obj)).ConnectTo {
15744                         if err := pcall(func() {
15745                                 (((*(*(struct {
15746                                         Param0 Content
15747
15748                                         Name   string
15749                                         Groups []Group
15750
15751                                         P1Type   Param1Type
15752                                         P2Type   Param2Type
15753                                         DrawType DrawType
15754
15755                                         Mesh  string
15756                                         Scale float32
15757                                         //mt:const uint8(6)
15758                                         Tiles        [6]TileDef
15759                                         OverlayTiles [6]TileDef
15760                                         //mt:const uint8(6)
15761                                         SpecialTiles [6]TileDef
15762
15763                                         Color   color.NRGBA
15764                                         Palette Texture
15765
15766                                         Waving       WaveType
15767                                         ConnectSides uint8
15768                                         ConnectTo    []Content
15769                                         InsideTint   color.NRGBA
15770                                         Level        uint8 // Must be < 128.
15771
15772                                         Translucent bool // Sunlight is scattered and becomes normal light.
15773                                         Transparent bool // Sunlight isn't scattered.
15774                                         LightSrc    uint8
15775
15776                                         GndContent   bool
15777                                         Collides     bool
15778                                         Pointable    bool
15779                                         Diggable     bool
15780                                         Climbable    bool
15781                                         Replaceable  bool
15782                                         OnRightClick bool
15783
15784                                         DmgPerSec int32
15785
15786                                         LiquidType   LiquidType
15787                                         FlowingAlt   string
15788                                         SrcAlt       string
15789                                         Viscosity    uint8 // 0-7
15790                                         LiqRenewable bool
15791                                         FlowRange    uint8
15792                                         DrownDmg     uint8
15793                                         Floodable    bool
15794
15795                                         DrawBox, ColBox, SelBox NodeBox
15796
15797                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15798
15799                                         LegacyFaceDir bool
15800                                         LegacyMounted bool
15801
15802                                         DigPredict string
15803
15804                                         MaxLvl uint8
15805
15806                                         AlphaUse
15807                                 }))(obj)).ConnectTo)[local245]).serialize(w)
15808                         }); err != nil {
15809                                 if err == io.EOF {
15810                                         chk(io.EOF)
15811                                 }
15812                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
15813                         }
15814                 }
15815                 {
15816                         x := (*(*(struct {
15817                                 Param0 Content
15818
15819                                 Name   string
15820                                 Groups []Group
15821
15822                                 P1Type   Param1Type
15823                                 P2Type   Param2Type
15824                                 DrawType DrawType
15825
15826                                 Mesh  string
15827                                 Scale float32
15828                                 //mt:const uint8(6)
15829                                 Tiles        [6]TileDef
15830                                 OverlayTiles [6]TileDef
15831                                 //mt:const uint8(6)
15832                                 SpecialTiles [6]TileDef
15833
15834                                 Color   color.NRGBA
15835                                 Palette Texture
15836
15837                                 Waving       WaveType
15838                                 ConnectSides uint8
15839                                 ConnectTo    []Content
15840                                 InsideTint   color.NRGBA
15841                                 Level        uint8 // Must be < 128.
15842
15843                                 Translucent bool // Sunlight is scattered and becomes normal light.
15844                                 Transparent bool // Sunlight isn't scattered.
15845                                 LightSrc    uint8
15846
15847                                 GndContent   bool
15848                                 Collides     bool
15849                                 Pointable    bool
15850                                 Diggable     bool
15851                                 Climbable    bool
15852                                 Replaceable  bool
15853                                 OnRightClick bool
15854
15855                                 DmgPerSec int32
15856
15857                                 LiquidType   LiquidType
15858                                 FlowingAlt   string
15859                                 SrcAlt       string
15860                                 Viscosity    uint8 // 0-7
15861                                 LiqRenewable bool
15862                                 FlowRange    uint8
15863                                 DrownDmg     uint8
15864                                 Floodable    bool
15865
15866                                 DrawBox, ColBox, SelBox NodeBox
15867
15868                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15869
15870                                 LegacyFaceDir bool
15871                                 LegacyMounted bool
15872
15873                                 DigPredict string
15874
15875                                 MaxLvl uint8
15876
15877                                 AlphaUse
15878                         }))(obj)).InsideTint
15879                         w.Write([]byte{x.A, x.R, x.G, x.B})
15880
15881                 }
15882                 {
15883                         x := (*(*(struct {
15884                                 Param0 Content
15885
15886                                 Name   string
15887                                 Groups []Group
15888
15889                                 P1Type   Param1Type
15890                                 P2Type   Param2Type
15891                                 DrawType DrawType
15892
15893                                 Mesh  string
15894                                 Scale float32
15895                                 //mt:const uint8(6)
15896                                 Tiles        [6]TileDef
15897                                 OverlayTiles [6]TileDef
15898                                 //mt:const uint8(6)
15899                                 SpecialTiles [6]TileDef
15900
15901                                 Color   color.NRGBA
15902                                 Palette Texture
15903
15904                                 Waving       WaveType
15905                                 ConnectSides uint8
15906                                 ConnectTo    []Content
15907                                 InsideTint   color.NRGBA
15908                                 Level        uint8 // Must be < 128.
15909
15910                                 Translucent bool // Sunlight is scattered and becomes normal light.
15911                                 Transparent bool // Sunlight isn't scattered.
15912                                 LightSrc    uint8
15913
15914                                 GndContent   bool
15915                                 Collides     bool
15916                                 Pointable    bool
15917                                 Diggable     bool
15918                                 Climbable    bool
15919                                 Replaceable  bool
15920                                 OnRightClick bool
15921
15922                                 DmgPerSec int32
15923
15924                                 LiquidType   LiquidType
15925                                 FlowingAlt   string
15926                                 SrcAlt       string
15927                                 Viscosity    uint8 // 0-7
15928                                 LiqRenewable bool
15929                                 FlowRange    uint8
15930                                 DrownDmg     uint8
15931                                 Floodable    bool
15932
15933                                 DrawBox, ColBox, SelBox NodeBox
15934
15935                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15936
15937                                 LegacyFaceDir bool
15938                                 LegacyMounted bool
15939
15940                                 DigPredict string
15941
15942                                 MaxLvl uint8
15943
15944                                 AlphaUse
15945                         }))(obj)).Level
15946                         write8(w, uint8(x))
15947                 }
15948                 {
15949                         x := (*(*(struct {
15950                                 Param0 Content
15951
15952                                 Name   string
15953                                 Groups []Group
15954
15955                                 P1Type   Param1Type
15956                                 P2Type   Param2Type
15957                                 DrawType DrawType
15958
15959                                 Mesh  string
15960                                 Scale float32
15961                                 //mt:const uint8(6)
15962                                 Tiles        [6]TileDef
15963                                 OverlayTiles [6]TileDef
15964                                 //mt:const uint8(6)
15965                                 SpecialTiles [6]TileDef
15966
15967                                 Color   color.NRGBA
15968                                 Palette Texture
15969
15970                                 Waving       WaveType
15971                                 ConnectSides uint8
15972                                 ConnectTo    []Content
15973                                 InsideTint   color.NRGBA
15974                                 Level        uint8 // Must be < 128.
15975
15976                                 Translucent bool // Sunlight is scattered and becomes normal light.
15977                                 Transparent bool // Sunlight isn't scattered.
15978                                 LightSrc    uint8
15979
15980                                 GndContent   bool
15981                                 Collides     bool
15982                                 Pointable    bool
15983                                 Diggable     bool
15984                                 Climbable    bool
15985                                 Replaceable  bool
15986                                 OnRightClick bool
15987
15988                                 DmgPerSec int32
15989
15990                                 LiquidType   LiquidType
15991                                 FlowingAlt   string
15992                                 SrcAlt       string
15993                                 Viscosity    uint8 // 0-7
15994                                 LiqRenewable bool
15995                                 FlowRange    uint8
15996                                 DrownDmg     uint8
15997                                 Floodable    bool
15998
15999                                 DrawBox, ColBox, SelBox NodeBox
16000
16001                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16002
16003                                 LegacyFaceDir bool
16004                                 LegacyMounted bool
16005
16006                                 DigPredict string
16007
16008                                 MaxLvl uint8
16009
16010                                 AlphaUse
16011                         }))(obj)).Translucent
16012                         if x {
16013                                 write8(w, 1)
16014                         } else {
16015                                 write8(w, 0)
16016                         }
16017
16018                 }
16019                 {
16020                         x := (*(*(struct {
16021                                 Param0 Content
16022
16023                                 Name   string
16024                                 Groups []Group
16025
16026                                 P1Type   Param1Type
16027                                 P2Type   Param2Type
16028                                 DrawType DrawType
16029
16030                                 Mesh  string
16031                                 Scale float32
16032                                 //mt:const uint8(6)
16033                                 Tiles        [6]TileDef
16034                                 OverlayTiles [6]TileDef
16035                                 //mt:const uint8(6)
16036                                 SpecialTiles [6]TileDef
16037
16038                                 Color   color.NRGBA
16039                                 Palette Texture
16040
16041                                 Waving       WaveType
16042                                 ConnectSides uint8
16043                                 ConnectTo    []Content
16044                                 InsideTint   color.NRGBA
16045                                 Level        uint8 // Must be < 128.
16046
16047                                 Translucent bool // Sunlight is scattered and becomes normal light.
16048                                 Transparent bool // Sunlight isn't scattered.
16049                                 LightSrc    uint8
16050
16051                                 GndContent   bool
16052                                 Collides     bool
16053                                 Pointable    bool
16054                                 Diggable     bool
16055                                 Climbable    bool
16056                                 Replaceable  bool
16057                                 OnRightClick bool
16058
16059                                 DmgPerSec int32
16060
16061                                 LiquidType   LiquidType
16062                                 FlowingAlt   string
16063                                 SrcAlt       string
16064                                 Viscosity    uint8 // 0-7
16065                                 LiqRenewable bool
16066                                 FlowRange    uint8
16067                                 DrownDmg     uint8
16068                                 Floodable    bool
16069
16070                                 DrawBox, ColBox, SelBox NodeBox
16071
16072                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16073
16074                                 LegacyFaceDir bool
16075                                 LegacyMounted bool
16076
16077                                 DigPredict string
16078
16079                                 MaxLvl uint8
16080
16081                                 AlphaUse
16082                         }))(obj)).Transparent
16083                         if x {
16084                                 write8(w, 1)
16085                         } else {
16086                                 write8(w, 0)
16087                         }
16088
16089                 }
16090                 {
16091                         x := (*(*(struct {
16092                                 Param0 Content
16093
16094                                 Name   string
16095                                 Groups []Group
16096
16097                                 P1Type   Param1Type
16098                                 P2Type   Param2Type
16099                                 DrawType DrawType
16100
16101                                 Mesh  string
16102                                 Scale float32
16103                                 //mt:const uint8(6)
16104                                 Tiles        [6]TileDef
16105                                 OverlayTiles [6]TileDef
16106                                 //mt:const uint8(6)
16107                                 SpecialTiles [6]TileDef
16108
16109                                 Color   color.NRGBA
16110                                 Palette Texture
16111
16112                                 Waving       WaveType
16113                                 ConnectSides uint8
16114                                 ConnectTo    []Content
16115                                 InsideTint   color.NRGBA
16116                                 Level        uint8 // Must be < 128.
16117
16118                                 Translucent bool // Sunlight is scattered and becomes normal light.
16119                                 Transparent bool // Sunlight isn't scattered.
16120                                 LightSrc    uint8
16121
16122                                 GndContent   bool
16123                                 Collides     bool
16124                                 Pointable    bool
16125                                 Diggable     bool
16126                                 Climbable    bool
16127                                 Replaceable  bool
16128                                 OnRightClick bool
16129
16130                                 DmgPerSec int32
16131
16132                                 LiquidType   LiquidType
16133                                 FlowingAlt   string
16134                                 SrcAlt       string
16135                                 Viscosity    uint8 // 0-7
16136                                 LiqRenewable bool
16137                                 FlowRange    uint8
16138                                 DrownDmg     uint8
16139                                 Floodable    bool
16140
16141                                 DrawBox, ColBox, SelBox NodeBox
16142
16143                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16144
16145                                 LegacyFaceDir bool
16146                                 LegacyMounted bool
16147
16148                                 DigPredict string
16149
16150                                 MaxLvl uint8
16151
16152                                 AlphaUse
16153                         }))(obj)).LightSrc
16154                         write8(w, uint8(x))
16155                 }
16156                 {
16157                         x := (*(*(struct {
16158                                 Param0 Content
16159
16160                                 Name   string
16161                                 Groups []Group
16162
16163                                 P1Type   Param1Type
16164                                 P2Type   Param2Type
16165                                 DrawType DrawType
16166
16167                                 Mesh  string
16168                                 Scale float32
16169                                 //mt:const uint8(6)
16170                                 Tiles        [6]TileDef
16171                                 OverlayTiles [6]TileDef
16172                                 //mt:const uint8(6)
16173                                 SpecialTiles [6]TileDef
16174
16175                                 Color   color.NRGBA
16176                                 Palette Texture
16177
16178                                 Waving       WaveType
16179                                 ConnectSides uint8
16180                                 ConnectTo    []Content
16181                                 InsideTint   color.NRGBA
16182                                 Level        uint8 // Must be < 128.
16183
16184                                 Translucent bool // Sunlight is scattered and becomes normal light.
16185                                 Transparent bool // Sunlight isn't scattered.
16186                                 LightSrc    uint8
16187
16188                                 GndContent   bool
16189                                 Collides     bool
16190                                 Pointable    bool
16191                                 Diggable     bool
16192                                 Climbable    bool
16193                                 Replaceable  bool
16194                                 OnRightClick bool
16195
16196                                 DmgPerSec int32
16197
16198                                 LiquidType   LiquidType
16199                                 FlowingAlt   string
16200                                 SrcAlt       string
16201                                 Viscosity    uint8 // 0-7
16202                                 LiqRenewable bool
16203                                 FlowRange    uint8
16204                                 DrownDmg     uint8
16205                                 Floodable    bool
16206
16207                                 DrawBox, ColBox, SelBox NodeBox
16208
16209                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16210
16211                                 LegacyFaceDir bool
16212                                 LegacyMounted bool
16213
16214                                 DigPredict string
16215
16216                                 MaxLvl uint8
16217
16218                                 AlphaUse
16219                         }))(obj)).GndContent
16220                         if x {
16221                                 write8(w, 1)
16222                         } else {
16223                                 write8(w, 0)
16224                         }
16225
16226                 }
16227                 {
16228                         x := (*(*(struct {
16229                                 Param0 Content
16230
16231                                 Name   string
16232                                 Groups []Group
16233
16234                                 P1Type   Param1Type
16235                                 P2Type   Param2Type
16236                                 DrawType DrawType
16237
16238                                 Mesh  string
16239                                 Scale float32
16240                                 //mt:const uint8(6)
16241                                 Tiles        [6]TileDef
16242                                 OverlayTiles [6]TileDef
16243                                 //mt:const uint8(6)
16244                                 SpecialTiles [6]TileDef
16245
16246                                 Color   color.NRGBA
16247                                 Palette Texture
16248
16249                                 Waving       WaveType
16250                                 ConnectSides uint8
16251                                 ConnectTo    []Content
16252                                 InsideTint   color.NRGBA
16253                                 Level        uint8 // Must be < 128.
16254
16255                                 Translucent bool // Sunlight is scattered and becomes normal light.
16256                                 Transparent bool // Sunlight isn't scattered.
16257                                 LightSrc    uint8
16258
16259                                 GndContent   bool
16260                                 Collides     bool
16261                                 Pointable    bool
16262                                 Diggable     bool
16263                                 Climbable    bool
16264                                 Replaceable  bool
16265                                 OnRightClick bool
16266
16267                                 DmgPerSec int32
16268
16269                                 LiquidType   LiquidType
16270                                 FlowingAlt   string
16271                                 SrcAlt       string
16272                                 Viscosity    uint8 // 0-7
16273                                 LiqRenewable bool
16274                                 FlowRange    uint8
16275                                 DrownDmg     uint8
16276                                 Floodable    bool
16277
16278                                 DrawBox, ColBox, SelBox NodeBox
16279
16280                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16281
16282                                 LegacyFaceDir bool
16283                                 LegacyMounted bool
16284
16285                                 DigPredict string
16286
16287                                 MaxLvl uint8
16288
16289                                 AlphaUse
16290                         }))(obj)).Collides
16291                         if x {
16292                                 write8(w, 1)
16293                         } else {
16294                                 write8(w, 0)
16295                         }
16296
16297                 }
16298                 {
16299                         x := (*(*(struct {
16300                                 Param0 Content
16301
16302                                 Name   string
16303                                 Groups []Group
16304
16305                                 P1Type   Param1Type
16306                                 P2Type   Param2Type
16307                                 DrawType DrawType
16308
16309                                 Mesh  string
16310                                 Scale float32
16311                                 //mt:const uint8(6)
16312                                 Tiles        [6]TileDef
16313                                 OverlayTiles [6]TileDef
16314                                 //mt:const uint8(6)
16315                                 SpecialTiles [6]TileDef
16316
16317                                 Color   color.NRGBA
16318                                 Palette Texture
16319
16320                                 Waving       WaveType
16321                                 ConnectSides uint8
16322                                 ConnectTo    []Content
16323                                 InsideTint   color.NRGBA
16324                                 Level        uint8 // Must be < 128.
16325
16326                                 Translucent bool // Sunlight is scattered and becomes normal light.
16327                                 Transparent bool // Sunlight isn't scattered.
16328                                 LightSrc    uint8
16329
16330                                 GndContent   bool
16331                                 Collides     bool
16332                                 Pointable    bool
16333                                 Diggable     bool
16334                                 Climbable    bool
16335                                 Replaceable  bool
16336                                 OnRightClick bool
16337
16338                                 DmgPerSec int32
16339
16340                                 LiquidType   LiquidType
16341                                 FlowingAlt   string
16342                                 SrcAlt       string
16343                                 Viscosity    uint8 // 0-7
16344                                 LiqRenewable bool
16345                                 FlowRange    uint8
16346                                 DrownDmg     uint8
16347                                 Floodable    bool
16348
16349                                 DrawBox, ColBox, SelBox NodeBox
16350
16351                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16352
16353                                 LegacyFaceDir bool
16354                                 LegacyMounted bool
16355
16356                                 DigPredict string
16357
16358                                 MaxLvl uint8
16359
16360                                 AlphaUse
16361                         }))(obj)).Pointable
16362                         if x {
16363                                 write8(w, 1)
16364                         } else {
16365                                 write8(w, 0)
16366                         }
16367
16368                 }
16369                 {
16370                         x := (*(*(struct {
16371                                 Param0 Content
16372
16373                                 Name   string
16374                                 Groups []Group
16375
16376                                 P1Type   Param1Type
16377                                 P2Type   Param2Type
16378                                 DrawType DrawType
16379
16380                                 Mesh  string
16381                                 Scale float32
16382                                 //mt:const uint8(6)
16383                                 Tiles        [6]TileDef
16384                                 OverlayTiles [6]TileDef
16385                                 //mt:const uint8(6)
16386                                 SpecialTiles [6]TileDef
16387
16388                                 Color   color.NRGBA
16389                                 Palette Texture
16390
16391                                 Waving       WaveType
16392                                 ConnectSides uint8
16393                                 ConnectTo    []Content
16394                                 InsideTint   color.NRGBA
16395                                 Level        uint8 // Must be < 128.
16396
16397                                 Translucent bool // Sunlight is scattered and becomes normal light.
16398                                 Transparent bool // Sunlight isn't scattered.
16399                                 LightSrc    uint8
16400
16401                                 GndContent   bool
16402                                 Collides     bool
16403                                 Pointable    bool
16404                                 Diggable     bool
16405                                 Climbable    bool
16406                                 Replaceable  bool
16407                                 OnRightClick bool
16408
16409                                 DmgPerSec int32
16410
16411                                 LiquidType   LiquidType
16412                                 FlowingAlt   string
16413                                 SrcAlt       string
16414                                 Viscosity    uint8 // 0-7
16415                                 LiqRenewable bool
16416                                 FlowRange    uint8
16417                                 DrownDmg     uint8
16418                                 Floodable    bool
16419
16420                                 DrawBox, ColBox, SelBox NodeBox
16421
16422                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16423
16424                                 LegacyFaceDir bool
16425                                 LegacyMounted bool
16426
16427                                 DigPredict string
16428
16429                                 MaxLvl uint8
16430
16431                                 AlphaUse
16432                         }))(obj)).Diggable
16433                         if x {
16434                                 write8(w, 1)
16435                         } else {
16436                                 write8(w, 0)
16437                         }
16438
16439                 }
16440                 {
16441                         x := (*(*(struct {
16442                                 Param0 Content
16443
16444                                 Name   string
16445                                 Groups []Group
16446
16447                                 P1Type   Param1Type
16448                                 P2Type   Param2Type
16449                                 DrawType DrawType
16450
16451                                 Mesh  string
16452                                 Scale float32
16453                                 //mt:const uint8(6)
16454                                 Tiles        [6]TileDef
16455                                 OverlayTiles [6]TileDef
16456                                 //mt:const uint8(6)
16457                                 SpecialTiles [6]TileDef
16458
16459                                 Color   color.NRGBA
16460                                 Palette Texture
16461
16462                                 Waving       WaveType
16463                                 ConnectSides uint8
16464                                 ConnectTo    []Content
16465                                 InsideTint   color.NRGBA
16466                                 Level        uint8 // Must be < 128.
16467
16468                                 Translucent bool // Sunlight is scattered and becomes normal light.
16469                                 Transparent bool // Sunlight isn't scattered.
16470                                 LightSrc    uint8
16471
16472                                 GndContent   bool
16473                                 Collides     bool
16474                                 Pointable    bool
16475                                 Diggable     bool
16476                                 Climbable    bool
16477                                 Replaceable  bool
16478                                 OnRightClick bool
16479
16480                                 DmgPerSec int32
16481
16482                                 LiquidType   LiquidType
16483                                 FlowingAlt   string
16484                                 SrcAlt       string
16485                                 Viscosity    uint8 // 0-7
16486                                 LiqRenewable bool
16487                                 FlowRange    uint8
16488                                 DrownDmg     uint8
16489                                 Floodable    bool
16490
16491                                 DrawBox, ColBox, SelBox NodeBox
16492
16493                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16494
16495                                 LegacyFaceDir bool
16496                                 LegacyMounted bool
16497
16498                                 DigPredict string
16499
16500                                 MaxLvl uint8
16501
16502                                 AlphaUse
16503                         }))(obj)).Climbable
16504                         if x {
16505                                 write8(w, 1)
16506                         } else {
16507                                 write8(w, 0)
16508                         }
16509
16510                 }
16511                 {
16512                         x := (*(*(struct {
16513                                 Param0 Content
16514
16515                                 Name   string
16516                                 Groups []Group
16517
16518                                 P1Type   Param1Type
16519                                 P2Type   Param2Type
16520                                 DrawType DrawType
16521
16522                                 Mesh  string
16523                                 Scale float32
16524                                 //mt:const uint8(6)
16525                                 Tiles        [6]TileDef
16526                                 OverlayTiles [6]TileDef
16527                                 //mt:const uint8(6)
16528                                 SpecialTiles [6]TileDef
16529
16530                                 Color   color.NRGBA
16531                                 Palette Texture
16532
16533                                 Waving       WaveType
16534                                 ConnectSides uint8
16535                                 ConnectTo    []Content
16536                                 InsideTint   color.NRGBA
16537                                 Level        uint8 // Must be < 128.
16538
16539                                 Translucent bool // Sunlight is scattered and becomes normal light.
16540                                 Transparent bool // Sunlight isn't scattered.
16541                                 LightSrc    uint8
16542
16543                                 GndContent   bool
16544                                 Collides     bool
16545                                 Pointable    bool
16546                                 Diggable     bool
16547                                 Climbable    bool
16548                                 Replaceable  bool
16549                                 OnRightClick bool
16550
16551                                 DmgPerSec int32
16552
16553                                 LiquidType   LiquidType
16554                                 FlowingAlt   string
16555                                 SrcAlt       string
16556                                 Viscosity    uint8 // 0-7
16557                                 LiqRenewable bool
16558                                 FlowRange    uint8
16559                                 DrownDmg     uint8
16560                                 Floodable    bool
16561
16562                                 DrawBox, ColBox, SelBox NodeBox
16563
16564                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16565
16566                                 LegacyFaceDir bool
16567                                 LegacyMounted bool
16568
16569                                 DigPredict string
16570
16571                                 MaxLvl uint8
16572
16573                                 AlphaUse
16574                         }))(obj)).Replaceable
16575                         if x {
16576                                 write8(w, 1)
16577                         } else {
16578                                 write8(w, 0)
16579                         }
16580
16581                 }
16582                 {
16583                         x := (*(*(struct {
16584                                 Param0 Content
16585
16586                                 Name   string
16587                                 Groups []Group
16588
16589                                 P1Type   Param1Type
16590                                 P2Type   Param2Type
16591                                 DrawType DrawType
16592
16593                                 Mesh  string
16594                                 Scale float32
16595                                 //mt:const uint8(6)
16596                                 Tiles        [6]TileDef
16597                                 OverlayTiles [6]TileDef
16598                                 //mt:const uint8(6)
16599                                 SpecialTiles [6]TileDef
16600
16601                                 Color   color.NRGBA
16602                                 Palette Texture
16603
16604                                 Waving       WaveType
16605                                 ConnectSides uint8
16606                                 ConnectTo    []Content
16607                                 InsideTint   color.NRGBA
16608                                 Level        uint8 // Must be < 128.
16609
16610                                 Translucent bool // Sunlight is scattered and becomes normal light.
16611                                 Transparent bool // Sunlight isn't scattered.
16612                                 LightSrc    uint8
16613
16614                                 GndContent   bool
16615                                 Collides     bool
16616                                 Pointable    bool
16617                                 Diggable     bool
16618                                 Climbable    bool
16619                                 Replaceable  bool
16620                                 OnRightClick bool
16621
16622                                 DmgPerSec int32
16623
16624                                 LiquidType   LiquidType
16625                                 FlowingAlt   string
16626                                 SrcAlt       string
16627                                 Viscosity    uint8 // 0-7
16628                                 LiqRenewable bool
16629                                 FlowRange    uint8
16630                                 DrownDmg     uint8
16631                                 Floodable    bool
16632
16633                                 DrawBox, ColBox, SelBox NodeBox
16634
16635                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16636
16637                                 LegacyFaceDir bool
16638                                 LegacyMounted bool
16639
16640                                 DigPredict string
16641
16642                                 MaxLvl uint8
16643
16644                                 AlphaUse
16645                         }))(obj)).OnRightClick
16646                         if x {
16647                                 write8(w, 1)
16648                         } else {
16649                                 write8(w, 0)
16650                         }
16651
16652                 }
16653                 {
16654                         x := (*(*(struct {
16655                                 Param0 Content
16656
16657                                 Name   string
16658                                 Groups []Group
16659
16660                                 P1Type   Param1Type
16661                                 P2Type   Param2Type
16662                                 DrawType DrawType
16663
16664                                 Mesh  string
16665                                 Scale float32
16666                                 //mt:const uint8(6)
16667                                 Tiles        [6]TileDef
16668                                 OverlayTiles [6]TileDef
16669                                 //mt:const uint8(6)
16670                                 SpecialTiles [6]TileDef
16671
16672                                 Color   color.NRGBA
16673                                 Palette Texture
16674
16675                                 Waving       WaveType
16676                                 ConnectSides uint8
16677                                 ConnectTo    []Content
16678                                 InsideTint   color.NRGBA
16679                                 Level        uint8 // Must be < 128.
16680
16681                                 Translucent bool // Sunlight is scattered and becomes normal light.
16682                                 Transparent bool // Sunlight isn't scattered.
16683                                 LightSrc    uint8
16684
16685                                 GndContent   bool
16686                                 Collides     bool
16687                                 Pointable    bool
16688                                 Diggable     bool
16689                                 Climbable    bool
16690                                 Replaceable  bool
16691                                 OnRightClick bool
16692
16693                                 DmgPerSec int32
16694
16695                                 LiquidType   LiquidType
16696                                 FlowingAlt   string
16697                                 SrcAlt       string
16698                                 Viscosity    uint8 // 0-7
16699                                 LiqRenewable bool
16700                                 FlowRange    uint8
16701                                 DrownDmg     uint8
16702                                 Floodable    bool
16703
16704                                 DrawBox, ColBox, SelBox NodeBox
16705
16706                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16707
16708                                 LegacyFaceDir bool
16709                                 LegacyMounted bool
16710
16711                                 DigPredict string
16712
16713                                 MaxLvl uint8
16714
16715                                 AlphaUse
16716                         }))(obj)).DmgPerSec
16717                         write32(w, uint32(x))
16718                 }
16719                 if err := pcall(func() {
16720                         ((*(*(struct {
16721                                 Param0 Content
16722
16723                                 Name   string
16724                                 Groups []Group
16725
16726                                 P1Type   Param1Type
16727                                 P2Type   Param2Type
16728                                 DrawType DrawType
16729
16730                                 Mesh  string
16731                                 Scale float32
16732                                 //mt:const uint8(6)
16733                                 Tiles        [6]TileDef
16734                                 OverlayTiles [6]TileDef
16735                                 //mt:const uint8(6)
16736                                 SpecialTiles [6]TileDef
16737
16738                                 Color   color.NRGBA
16739                                 Palette Texture
16740
16741                                 Waving       WaveType
16742                                 ConnectSides uint8
16743                                 ConnectTo    []Content
16744                                 InsideTint   color.NRGBA
16745                                 Level        uint8 // Must be < 128.
16746
16747                                 Translucent bool // Sunlight is scattered and becomes normal light.
16748                                 Transparent bool // Sunlight isn't scattered.
16749                                 LightSrc    uint8
16750
16751                                 GndContent   bool
16752                                 Collides     bool
16753                                 Pointable    bool
16754                                 Diggable     bool
16755                                 Climbable    bool
16756                                 Replaceable  bool
16757                                 OnRightClick bool
16758
16759                                 DmgPerSec int32
16760
16761                                 LiquidType   LiquidType
16762                                 FlowingAlt   string
16763                                 SrcAlt       string
16764                                 Viscosity    uint8 // 0-7
16765                                 LiqRenewable bool
16766                                 FlowRange    uint8
16767                                 DrownDmg     uint8
16768                                 Floodable    bool
16769
16770                                 DrawBox, ColBox, SelBox NodeBox
16771
16772                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16773
16774                                 LegacyFaceDir bool
16775                                 LegacyMounted bool
16776
16777                                 DigPredict string
16778
16779                                 MaxLvl uint8
16780
16781                                 AlphaUse
16782                         }))(obj)).LiquidType).serialize(w)
16783                 }); err != nil {
16784                         if err == io.EOF {
16785                                 chk(io.EOF)
16786                         }
16787                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LiquidType", err))
16788                 }
16789                 if len(([]byte((*(*(struct {
16790                         Param0 Content
16791
16792                         Name   string
16793                         Groups []Group
16794
16795                         P1Type   Param1Type
16796                         P2Type   Param2Type
16797                         DrawType DrawType
16798
16799                         Mesh  string
16800                         Scale float32
16801                         //mt:const uint8(6)
16802                         Tiles        [6]TileDef
16803                         OverlayTiles [6]TileDef
16804                         //mt:const uint8(6)
16805                         SpecialTiles [6]TileDef
16806
16807                         Color   color.NRGBA
16808                         Palette Texture
16809
16810                         Waving       WaveType
16811                         ConnectSides uint8
16812                         ConnectTo    []Content
16813                         InsideTint   color.NRGBA
16814                         Level        uint8 // Must be < 128.
16815
16816                         Translucent bool // Sunlight is scattered and becomes normal light.
16817                         Transparent bool // Sunlight isn't scattered.
16818                         LightSrc    uint8
16819
16820                         GndContent   bool
16821                         Collides     bool
16822                         Pointable    bool
16823                         Diggable     bool
16824                         Climbable    bool
16825                         Replaceable  bool
16826                         OnRightClick bool
16827
16828                         DmgPerSec int32
16829
16830                         LiquidType   LiquidType
16831                         FlowingAlt   string
16832                         SrcAlt       string
16833                         Viscosity    uint8 // 0-7
16834                         LiqRenewable bool
16835                         FlowRange    uint8
16836                         DrownDmg     uint8
16837                         Floodable    bool
16838
16839                         DrawBox, ColBox, SelBox NodeBox
16840
16841                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16842
16843                         LegacyFaceDir bool
16844                         LegacyMounted bool
16845
16846                         DigPredict string
16847
16848                         MaxLvl uint8
16849
16850                         AlphaUse
16851                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
16852                         chk(ErrTooLong)
16853                 }
16854                 {
16855                         x := uint16(len(([]byte((*(*(struct {
16856                                 Param0 Content
16857
16858                                 Name   string
16859                                 Groups []Group
16860
16861                                 P1Type   Param1Type
16862                                 P2Type   Param2Type
16863                                 DrawType DrawType
16864
16865                                 Mesh  string
16866                                 Scale float32
16867                                 //mt:const uint8(6)
16868                                 Tiles        [6]TileDef
16869                                 OverlayTiles [6]TileDef
16870                                 //mt:const uint8(6)
16871                                 SpecialTiles [6]TileDef
16872
16873                                 Color   color.NRGBA
16874                                 Palette Texture
16875
16876                                 Waving       WaveType
16877                                 ConnectSides uint8
16878                                 ConnectTo    []Content
16879                                 InsideTint   color.NRGBA
16880                                 Level        uint8 // Must be < 128.
16881
16882                                 Translucent bool // Sunlight is scattered and becomes normal light.
16883                                 Transparent bool // Sunlight isn't scattered.
16884                                 LightSrc    uint8
16885
16886                                 GndContent   bool
16887                                 Collides     bool
16888                                 Pointable    bool
16889                                 Diggable     bool
16890                                 Climbable    bool
16891                                 Replaceable  bool
16892                                 OnRightClick bool
16893
16894                                 DmgPerSec int32
16895
16896                                 LiquidType   LiquidType
16897                                 FlowingAlt   string
16898                                 SrcAlt       string
16899                                 Viscosity    uint8 // 0-7
16900                                 LiqRenewable bool
16901                                 FlowRange    uint8
16902                                 DrownDmg     uint8
16903                                 Floodable    bool
16904
16905                                 DrawBox, ColBox, SelBox NodeBox
16906
16907                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16908
16909                                 LegacyFaceDir bool
16910                                 LegacyMounted bool
16911
16912                                 DigPredict string
16913
16914                                 MaxLvl uint8
16915
16916                                 AlphaUse
16917                         }))(obj)).FlowingAlt))))
16918                         write16(w, uint16(x))
16919                 }
16920                 {
16921                         _, err := w.Write(([]byte((*(*(struct {
16922                                 Param0 Content
16923
16924                                 Name   string
16925                                 Groups []Group
16926
16927                                 P1Type   Param1Type
16928                                 P2Type   Param2Type
16929                                 DrawType DrawType
16930
16931                                 Mesh  string
16932                                 Scale float32
16933                                 //mt:const uint8(6)
16934                                 Tiles        [6]TileDef
16935                                 OverlayTiles [6]TileDef
16936                                 //mt:const uint8(6)
16937                                 SpecialTiles [6]TileDef
16938
16939                                 Color   color.NRGBA
16940                                 Palette Texture
16941
16942                                 Waving       WaveType
16943                                 ConnectSides uint8
16944                                 ConnectTo    []Content
16945                                 InsideTint   color.NRGBA
16946                                 Level        uint8 // Must be < 128.
16947
16948                                 Translucent bool // Sunlight is scattered and becomes normal light.
16949                                 Transparent bool // Sunlight isn't scattered.
16950                                 LightSrc    uint8
16951
16952                                 GndContent   bool
16953                                 Collides     bool
16954                                 Pointable    bool
16955                                 Diggable     bool
16956                                 Climbable    bool
16957                                 Replaceable  bool
16958                                 OnRightClick bool
16959
16960                                 DmgPerSec int32
16961
16962                                 LiquidType   LiquidType
16963                                 FlowingAlt   string
16964                                 SrcAlt       string
16965                                 Viscosity    uint8 // 0-7
16966                                 LiqRenewable bool
16967                                 FlowRange    uint8
16968                                 DrownDmg     uint8
16969                                 Floodable    bool
16970
16971                                 DrawBox, ColBox, SelBox NodeBox
16972
16973                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16974
16975                                 LegacyFaceDir bool
16976                                 LegacyMounted bool
16977
16978                                 DigPredict string
16979
16980                                 MaxLvl uint8
16981
16982                                 AlphaUse
16983                         }))(obj)).FlowingAlt))[:])
16984                         chk(err)
16985                 }
16986                 if len(([]byte((*(*(struct {
16987                         Param0 Content
16988
16989                         Name   string
16990                         Groups []Group
16991
16992                         P1Type   Param1Type
16993                         P2Type   Param2Type
16994                         DrawType DrawType
16995
16996                         Mesh  string
16997                         Scale float32
16998                         //mt:const uint8(6)
16999                         Tiles        [6]TileDef
17000                         OverlayTiles [6]TileDef
17001                         //mt:const uint8(6)
17002                         SpecialTiles [6]TileDef
17003
17004                         Color   color.NRGBA
17005                         Palette Texture
17006
17007                         Waving       WaveType
17008                         ConnectSides uint8
17009                         ConnectTo    []Content
17010                         InsideTint   color.NRGBA
17011                         Level        uint8 // Must be < 128.
17012
17013                         Translucent bool // Sunlight is scattered and becomes normal light.
17014                         Transparent bool // Sunlight isn't scattered.
17015                         LightSrc    uint8
17016
17017                         GndContent   bool
17018                         Collides     bool
17019                         Pointable    bool
17020                         Diggable     bool
17021                         Climbable    bool
17022                         Replaceable  bool
17023                         OnRightClick bool
17024
17025                         DmgPerSec int32
17026
17027                         LiquidType   LiquidType
17028                         FlowingAlt   string
17029                         SrcAlt       string
17030                         Viscosity    uint8 // 0-7
17031                         LiqRenewable bool
17032                         FlowRange    uint8
17033                         DrownDmg     uint8
17034                         Floodable    bool
17035
17036                         DrawBox, ColBox, SelBox NodeBox
17037
17038                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17039
17040                         LegacyFaceDir bool
17041                         LegacyMounted bool
17042
17043                         DigPredict string
17044
17045                         MaxLvl uint8
17046
17047                         AlphaUse
17048                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17049                         chk(ErrTooLong)
17050                 }
17051                 {
17052                         x := uint16(len(([]byte((*(*(struct {
17053                                 Param0 Content
17054
17055                                 Name   string
17056                                 Groups []Group
17057
17058                                 P1Type   Param1Type
17059                                 P2Type   Param2Type
17060                                 DrawType DrawType
17061
17062                                 Mesh  string
17063                                 Scale float32
17064                                 //mt:const uint8(6)
17065                                 Tiles        [6]TileDef
17066                                 OverlayTiles [6]TileDef
17067                                 //mt:const uint8(6)
17068                                 SpecialTiles [6]TileDef
17069
17070                                 Color   color.NRGBA
17071                                 Palette Texture
17072
17073                                 Waving       WaveType
17074                                 ConnectSides uint8
17075                                 ConnectTo    []Content
17076                                 InsideTint   color.NRGBA
17077                                 Level        uint8 // Must be < 128.
17078
17079                                 Translucent bool // Sunlight is scattered and becomes normal light.
17080                                 Transparent bool // Sunlight isn't scattered.
17081                                 LightSrc    uint8
17082
17083                                 GndContent   bool
17084                                 Collides     bool
17085                                 Pointable    bool
17086                                 Diggable     bool
17087                                 Climbable    bool
17088                                 Replaceable  bool
17089                                 OnRightClick bool
17090
17091                                 DmgPerSec int32
17092
17093                                 LiquidType   LiquidType
17094                                 FlowingAlt   string
17095                                 SrcAlt       string
17096                                 Viscosity    uint8 // 0-7
17097                                 LiqRenewable bool
17098                                 FlowRange    uint8
17099                                 DrownDmg     uint8
17100                                 Floodable    bool
17101
17102                                 DrawBox, ColBox, SelBox NodeBox
17103
17104                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17105
17106                                 LegacyFaceDir bool
17107                                 LegacyMounted bool
17108
17109                                 DigPredict string
17110
17111                                 MaxLvl uint8
17112
17113                                 AlphaUse
17114                         }))(obj)).SrcAlt))))
17115                         write16(w, uint16(x))
17116                 }
17117                 {
17118                         _, err := w.Write(([]byte((*(*(struct {
17119                                 Param0 Content
17120
17121                                 Name   string
17122                                 Groups []Group
17123
17124                                 P1Type   Param1Type
17125                                 P2Type   Param2Type
17126                                 DrawType DrawType
17127
17128                                 Mesh  string
17129                                 Scale float32
17130                                 //mt:const uint8(6)
17131                                 Tiles        [6]TileDef
17132                                 OverlayTiles [6]TileDef
17133                                 //mt:const uint8(6)
17134                                 SpecialTiles [6]TileDef
17135
17136                                 Color   color.NRGBA
17137                                 Palette Texture
17138
17139                                 Waving       WaveType
17140                                 ConnectSides uint8
17141                                 ConnectTo    []Content
17142                                 InsideTint   color.NRGBA
17143                                 Level        uint8 // Must be < 128.
17144
17145                                 Translucent bool // Sunlight is scattered and becomes normal light.
17146                                 Transparent bool // Sunlight isn't scattered.
17147                                 LightSrc    uint8
17148
17149                                 GndContent   bool
17150                                 Collides     bool
17151                                 Pointable    bool
17152                                 Diggable     bool
17153                                 Climbable    bool
17154                                 Replaceable  bool
17155                                 OnRightClick bool
17156
17157                                 DmgPerSec int32
17158
17159                                 LiquidType   LiquidType
17160                                 FlowingAlt   string
17161                                 SrcAlt       string
17162                                 Viscosity    uint8 // 0-7
17163                                 LiqRenewable bool
17164                                 FlowRange    uint8
17165                                 DrownDmg     uint8
17166                                 Floodable    bool
17167
17168                                 DrawBox, ColBox, SelBox NodeBox
17169
17170                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17171
17172                                 LegacyFaceDir bool
17173                                 LegacyMounted bool
17174
17175                                 DigPredict string
17176
17177                                 MaxLvl uint8
17178
17179                                 AlphaUse
17180                         }))(obj)).SrcAlt))[:])
17181                         chk(err)
17182                 }
17183                 {
17184                         x := (*(*(struct {
17185                                 Param0 Content
17186
17187                                 Name   string
17188                                 Groups []Group
17189
17190                                 P1Type   Param1Type
17191                                 P2Type   Param2Type
17192                                 DrawType DrawType
17193
17194                                 Mesh  string
17195                                 Scale float32
17196                                 //mt:const uint8(6)
17197                                 Tiles        [6]TileDef
17198                                 OverlayTiles [6]TileDef
17199                                 //mt:const uint8(6)
17200                                 SpecialTiles [6]TileDef
17201
17202                                 Color   color.NRGBA
17203                                 Palette Texture
17204
17205                                 Waving       WaveType
17206                                 ConnectSides uint8
17207                                 ConnectTo    []Content
17208                                 InsideTint   color.NRGBA
17209                                 Level        uint8 // Must be < 128.
17210
17211                                 Translucent bool // Sunlight is scattered and becomes normal light.
17212                                 Transparent bool // Sunlight isn't scattered.
17213                                 LightSrc    uint8
17214
17215                                 GndContent   bool
17216                                 Collides     bool
17217                                 Pointable    bool
17218                                 Diggable     bool
17219                                 Climbable    bool
17220                                 Replaceable  bool
17221                                 OnRightClick bool
17222
17223                                 DmgPerSec int32
17224
17225                                 LiquidType   LiquidType
17226                                 FlowingAlt   string
17227                                 SrcAlt       string
17228                                 Viscosity    uint8 // 0-7
17229                                 LiqRenewable bool
17230                                 FlowRange    uint8
17231                                 DrownDmg     uint8
17232                                 Floodable    bool
17233
17234                                 DrawBox, ColBox, SelBox NodeBox
17235
17236                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17237
17238                                 LegacyFaceDir bool
17239                                 LegacyMounted bool
17240
17241                                 DigPredict string
17242
17243                                 MaxLvl uint8
17244
17245                                 AlphaUse
17246                         }))(obj)).Viscosity
17247                         write8(w, uint8(x))
17248                 }
17249                 {
17250                         x := (*(*(struct {
17251                                 Param0 Content
17252
17253                                 Name   string
17254                                 Groups []Group
17255
17256                                 P1Type   Param1Type
17257                                 P2Type   Param2Type
17258                                 DrawType DrawType
17259
17260                                 Mesh  string
17261                                 Scale float32
17262                                 //mt:const uint8(6)
17263                                 Tiles        [6]TileDef
17264                                 OverlayTiles [6]TileDef
17265                                 //mt:const uint8(6)
17266                                 SpecialTiles [6]TileDef
17267
17268                                 Color   color.NRGBA
17269                                 Palette Texture
17270
17271                                 Waving       WaveType
17272                                 ConnectSides uint8
17273                                 ConnectTo    []Content
17274                                 InsideTint   color.NRGBA
17275                                 Level        uint8 // Must be < 128.
17276
17277                                 Translucent bool // Sunlight is scattered and becomes normal light.
17278                                 Transparent bool // Sunlight isn't scattered.
17279                                 LightSrc    uint8
17280
17281                                 GndContent   bool
17282                                 Collides     bool
17283                                 Pointable    bool
17284                                 Diggable     bool
17285                                 Climbable    bool
17286                                 Replaceable  bool
17287                                 OnRightClick bool
17288
17289                                 DmgPerSec int32
17290
17291                                 LiquidType   LiquidType
17292                                 FlowingAlt   string
17293                                 SrcAlt       string
17294                                 Viscosity    uint8 // 0-7
17295                                 LiqRenewable bool
17296                                 FlowRange    uint8
17297                                 DrownDmg     uint8
17298                                 Floodable    bool
17299
17300                                 DrawBox, ColBox, SelBox NodeBox
17301
17302                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17303
17304                                 LegacyFaceDir bool
17305                                 LegacyMounted bool
17306
17307                                 DigPredict string
17308
17309                                 MaxLvl uint8
17310
17311                                 AlphaUse
17312                         }))(obj)).LiqRenewable
17313                         if x {
17314                                 write8(w, 1)
17315                         } else {
17316                                 write8(w, 0)
17317                         }
17318
17319                 }
17320                 {
17321                         x := (*(*(struct {
17322                                 Param0 Content
17323
17324                                 Name   string
17325                                 Groups []Group
17326
17327                                 P1Type   Param1Type
17328                                 P2Type   Param2Type
17329                                 DrawType DrawType
17330
17331                                 Mesh  string
17332                                 Scale float32
17333                                 //mt:const uint8(6)
17334                                 Tiles        [6]TileDef
17335                                 OverlayTiles [6]TileDef
17336                                 //mt:const uint8(6)
17337                                 SpecialTiles [6]TileDef
17338
17339                                 Color   color.NRGBA
17340                                 Palette Texture
17341
17342                                 Waving       WaveType
17343                                 ConnectSides uint8
17344                                 ConnectTo    []Content
17345                                 InsideTint   color.NRGBA
17346                                 Level        uint8 // Must be < 128.
17347
17348                                 Translucent bool // Sunlight is scattered and becomes normal light.
17349                                 Transparent bool // Sunlight isn't scattered.
17350                                 LightSrc    uint8
17351
17352                                 GndContent   bool
17353                                 Collides     bool
17354                                 Pointable    bool
17355                                 Diggable     bool
17356                                 Climbable    bool
17357                                 Replaceable  bool
17358                                 OnRightClick bool
17359
17360                                 DmgPerSec int32
17361
17362                                 LiquidType   LiquidType
17363                                 FlowingAlt   string
17364                                 SrcAlt       string
17365                                 Viscosity    uint8 // 0-7
17366                                 LiqRenewable bool
17367                                 FlowRange    uint8
17368                                 DrownDmg     uint8
17369                                 Floodable    bool
17370
17371                                 DrawBox, ColBox, SelBox NodeBox
17372
17373                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17374
17375                                 LegacyFaceDir bool
17376                                 LegacyMounted bool
17377
17378                                 DigPredict string
17379
17380                                 MaxLvl uint8
17381
17382                                 AlphaUse
17383                         }))(obj)).FlowRange
17384                         write8(w, uint8(x))
17385                 }
17386                 {
17387                         x := (*(*(struct {
17388                                 Param0 Content
17389
17390                                 Name   string
17391                                 Groups []Group
17392
17393                                 P1Type   Param1Type
17394                                 P2Type   Param2Type
17395                                 DrawType DrawType
17396
17397                                 Mesh  string
17398                                 Scale float32
17399                                 //mt:const uint8(6)
17400                                 Tiles        [6]TileDef
17401                                 OverlayTiles [6]TileDef
17402                                 //mt:const uint8(6)
17403                                 SpecialTiles [6]TileDef
17404
17405                                 Color   color.NRGBA
17406                                 Palette Texture
17407
17408                                 Waving       WaveType
17409                                 ConnectSides uint8
17410                                 ConnectTo    []Content
17411                                 InsideTint   color.NRGBA
17412                                 Level        uint8 // Must be < 128.
17413
17414                                 Translucent bool // Sunlight is scattered and becomes normal light.
17415                                 Transparent bool // Sunlight isn't scattered.
17416                                 LightSrc    uint8
17417
17418                                 GndContent   bool
17419                                 Collides     bool
17420                                 Pointable    bool
17421                                 Diggable     bool
17422                                 Climbable    bool
17423                                 Replaceable  bool
17424                                 OnRightClick bool
17425
17426                                 DmgPerSec int32
17427
17428                                 LiquidType   LiquidType
17429                                 FlowingAlt   string
17430                                 SrcAlt       string
17431                                 Viscosity    uint8 // 0-7
17432                                 LiqRenewable bool
17433                                 FlowRange    uint8
17434                                 DrownDmg     uint8
17435                                 Floodable    bool
17436
17437                                 DrawBox, ColBox, SelBox NodeBox
17438
17439                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17440
17441                                 LegacyFaceDir bool
17442                                 LegacyMounted bool
17443
17444                                 DigPredict string
17445
17446                                 MaxLvl uint8
17447
17448                                 AlphaUse
17449                         }))(obj)).DrownDmg
17450                         write8(w, uint8(x))
17451                 }
17452                 {
17453                         x := (*(*(struct {
17454                                 Param0 Content
17455
17456                                 Name   string
17457                                 Groups []Group
17458
17459                                 P1Type   Param1Type
17460                                 P2Type   Param2Type
17461                                 DrawType DrawType
17462
17463                                 Mesh  string
17464                                 Scale float32
17465                                 //mt:const uint8(6)
17466                                 Tiles        [6]TileDef
17467                                 OverlayTiles [6]TileDef
17468                                 //mt:const uint8(6)
17469                                 SpecialTiles [6]TileDef
17470
17471                                 Color   color.NRGBA
17472                                 Palette Texture
17473
17474                                 Waving       WaveType
17475                                 ConnectSides uint8
17476                                 ConnectTo    []Content
17477                                 InsideTint   color.NRGBA
17478                                 Level        uint8 // Must be < 128.
17479
17480                                 Translucent bool // Sunlight is scattered and becomes normal light.
17481                                 Transparent bool // Sunlight isn't scattered.
17482                                 LightSrc    uint8
17483
17484                                 GndContent   bool
17485                                 Collides     bool
17486                                 Pointable    bool
17487                                 Diggable     bool
17488                                 Climbable    bool
17489                                 Replaceable  bool
17490                                 OnRightClick bool
17491
17492                                 DmgPerSec int32
17493
17494                                 LiquidType   LiquidType
17495                                 FlowingAlt   string
17496                                 SrcAlt       string
17497                                 Viscosity    uint8 // 0-7
17498                                 LiqRenewable bool
17499                                 FlowRange    uint8
17500                                 DrownDmg     uint8
17501                                 Floodable    bool
17502
17503                                 DrawBox, ColBox, SelBox NodeBox
17504
17505                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17506
17507                                 LegacyFaceDir bool
17508                                 LegacyMounted bool
17509
17510                                 DigPredict string
17511
17512                                 MaxLvl uint8
17513
17514                                 AlphaUse
17515                         }))(obj)).Floodable
17516                         if x {
17517                                 write8(w, 1)
17518                         } else {
17519                                 write8(w, 0)
17520                         }
17521
17522                 }
17523                 if err := pcall(func() {
17524                         ((*(*(struct {
17525                                 Param0 Content
17526
17527                                 Name   string
17528                                 Groups []Group
17529
17530                                 P1Type   Param1Type
17531                                 P2Type   Param2Type
17532                                 DrawType DrawType
17533
17534                                 Mesh  string
17535                                 Scale float32
17536                                 //mt:const uint8(6)
17537                                 Tiles        [6]TileDef
17538                                 OverlayTiles [6]TileDef
17539                                 //mt:const uint8(6)
17540                                 SpecialTiles [6]TileDef
17541
17542                                 Color   color.NRGBA
17543                                 Palette Texture
17544
17545                                 Waving       WaveType
17546                                 ConnectSides uint8
17547                                 ConnectTo    []Content
17548                                 InsideTint   color.NRGBA
17549                                 Level        uint8 // Must be < 128.
17550
17551                                 Translucent bool // Sunlight is scattered and becomes normal light.
17552                                 Transparent bool // Sunlight isn't scattered.
17553                                 LightSrc    uint8
17554
17555                                 GndContent   bool
17556                                 Collides     bool
17557                                 Pointable    bool
17558                                 Diggable     bool
17559                                 Climbable    bool
17560                                 Replaceable  bool
17561                                 OnRightClick bool
17562
17563                                 DmgPerSec int32
17564
17565                                 LiquidType   LiquidType
17566                                 FlowingAlt   string
17567                                 SrcAlt       string
17568                                 Viscosity    uint8 // 0-7
17569                                 LiqRenewable bool
17570                                 FlowRange    uint8
17571                                 DrownDmg     uint8
17572                                 Floodable    bool
17573
17574                                 DrawBox, ColBox, SelBox NodeBox
17575
17576                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17577
17578                                 LegacyFaceDir bool
17579                                 LegacyMounted bool
17580
17581                                 DigPredict string
17582
17583                                 MaxLvl uint8
17584
17585                                 AlphaUse
17586                         }))(obj)).DrawBox).serialize(w)
17587                 }); err != nil {
17588                         if err == io.EOF {
17589                                 chk(io.EOF)
17590                         }
17591                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
17592                 }
17593                 if err := pcall(func() {
17594                         ((*(*(struct {
17595                                 Param0 Content
17596
17597                                 Name   string
17598                                 Groups []Group
17599
17600                                 P1Type   Param1Type
17601                                 P2Type   Param2Type
17602                                 DrawType DrawType
17603
17604                                 Mesh  string
17605                                 Scale float32
17606                                 //mt:const uint8(6)
17607                                 Tiles        [6]TileDef
17608                                 OverlayTiles [6]TileDef
17609                                 //mt:const uint8(6)
17610                                 SpecialTiles [6]TileDef
17611
17612                                 Color   color.NRGBA
17613                                 Palette Texture
17614
17615                                 Waving       WaveType
17616                                 ConnectSides uint8
17617                                 ConnectTo    []Content
17618                                 InsideTint   color.NRGBA
17619                                 Level        uint8 // Must be < 128.
17620
17621                                 Translucent bool // Sunlight is scattered and becomes normal light.
17622                                 Transparent bool // Sunlight isn't scattered.
17623                                 LightSrc    uint8
17624
17625                                 GndContent   bool
17626                                 Collides     bool
17627                                 Pointable    bool
17628                                 Diggable     bool
17629                                 Climbable    bool
17630                                 Replaceable  bool
17631                                 OnRightClick bool
17632
17633                                 DmgPerSec int32
17634
17635                                 LiquidType   LiquidType
17636                                 FlowingAlt   string
17637                                 SrcAlt       string
17638                                 Viscosity    uint8 // 0-7
17639                                 LiqRenewable bool
17640                                 FlowRange    uint8
17641                                 DrownDmg     uint8
17642                                 Floodable    bool
17643
17644                                 DrawBox, ColBox, SelBox NodeBox
17645
17646                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17647
17648                                 LegacyFaceDir bool
17649                                 LegacyMounted bool
17650
17651                                 DigPredict string
17652
17653                                 MaxLvl uint8
17654
17655                                 AlphaUse
17656                         }))(obj)).ColBox).serialize(w)
17657                 }); err != nil {
17658                         if err == io.EOF {
17659                                 chk(io.EOF)
17660                         }
17661                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
17662                 }
17663                 if err := pcall(func() {
17664                         ((*(*(struct {
17665                                 Param0 Content
17666
17667                                 Name   string
17668                                 Groups []Group
17669
17670                                 P1Type   Param1Type
17671                                 P2Type   Param2Type
17672                                 DrawType DrawType
17673
17674                                 Mesh  string
17675                                 Scale float32
17676                                 //mt:const uint8(6)
17677                                 Tiles        [6]TileDef
17678                                 OverlayTiles [6]TileDef
17679                                 //mt:const uint8(6)
17680                                 SpecialTiles [6]TileDef
17681
17682                                 Color   color.NRGBA
17683                                 Palette Texture
17684
17685                                 Waving       WaveType
17686                                 ConnectSides uint8
17687                                 ConnectTo    []Content
17688                                 InsideTint   color.NRGBA
17689                                 Level        uint8 // Must be < 128.
17690
17691                                 Translucent bool // Sunlight is scattered and becomes normal light.
17692                                 Transparent bool // Sunlight isn't scattered.
17693                                 LightSrc    uint8
17694
17695                                 GndContent   bool
17696                                 Collides     bool
17697                                 Pointable    bool
17698                                 Diggable     bool
17699                                 Climbable    bool
17700                                 Replaceable  bool
17701                                 OnRightClick bool
17702
17703                                 DmgPerSec int32
17704
17705                                 LiquidType   LiquidType
17706                                 FlowingAlt   string
17707                                 SrcAlt       string
17708                                 Viscosity    uint8 // 0-7
17709                                 LiqRenewable bool
17710                                 FlowRange    uint8
17711                                 DrownDmg     uint8
17712                                 Floodable    bool
17713
17714                                 DrawBox, ColBox, SelBox NodeBox
17715
17716                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17717
17718                                 LegacyFaceDir bool
17719                                 LegacyMounted bool
17720
17721                                 DigPredict string
17722
17723                                 MaxLvl uint8
17724
17725                                 AlphaUse
17726                         }))(obj)).SelBox).serialize(w)
17727                 }); err != nil {
17728                         if err == io.EOF {
17729                                 chk(io.EOF)
17730                         }
17731                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
17732                 }
17733                 if err := pcall(func() {
17734                         ((*(*(struct {
17735                                 Param0 Content
17736
17737                                 Name   string
17738                                 Groups []Group
17739
17740                                 P1Type   Param1Type
17741                                 P2Type   Param2Type
17742                                 DrawType DrawType
17743
17744                                 Mesh  string
17745                                 Scale float32
17746                                 //mt:const uint8(6)
17747                                 Tiles        [6]TileDef
17748                                 OverlayTiles [6]TileDef
17749                                 //mt:const uint8(6)
17750                                 SpecialTiles [6]TileDef
17751
17752                                 Color   color.NRGBA
17753                                 Palette Texture
17754
17755                                 Waving       WaveType
17756                                 ConnectSides uint8
17757                                 ConnectTo    []Content
17758                                 InsideTint   color.NRGBA
17759                                 Level        uint8 // Must be < 128.
17760
17761                                 Translucent bool // Sunlight is scattered and becomes normal light.
17762                                 Transparent bool // Sunlight isn't scattered.
17763                                 LightSrc    uint8
17764
17765                                 GndContent   bool
17766                                 Collides     bool
17767                                 Pointable    bool
17768                                 Diggable     bool
17769                                 Climbable    bool
17770                                 Replaceable  bool
17771                                 OnRightClick bool
17772
17773                                 DmgPerSec int32
17774
17775                                 LiquidType   LiquidType
17776                                 FlowingAlt   string
17777                                 SrcAlt       string
17778                                 Viscosity    uint8 // 0-7
17779                                 LiqRenewable bool
17780                                 FlowRange    uint8
17781                                 DrownDmg     uint8
17782                                 Floodable    bool
17783
17784                                 DrawBox, ColBox, SelBox NodeBox
17785
17786                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17787
17788                                 LegacyFaceDir bool
17789                                 LegacyMounted bool
17790
17791                                 DigPredict string
17792
17793                                 MaxLvl uint8
17794
17795                                 AlphaUse
17796                         }))(obj)).FootstepSnd).serialize(w)
17797                 }); err != nil {
17798                         if err == io.EOF {
17799                                 chk(io.EOF)
17800                         }
17801                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
17802                 }
17803                 if err := pcall(func() {
17804                         ((*(*(struct {
17805                                 Param0 Content
17806
17807                                 Name   string
17808                                 Groups []Group
17809
17810                                 P1Type   Param1Type
17811                                 P2Type   Param2Type
17812                                 DrawType DrawType
17813
17814                                 Mesh  string
17815                                 Scale float32
17816                                 //mt:const uint8(6)
17817                                 Tiles        [6]TileDef
17818                                 OverlayTiles [6]TileDef
17819                                 //mt:const uint8(6)
17820                                 SpecialTiles [6]TileDef
17821
17822                                 Color   color.NRGBA
17823                                 Palette Texture
17824
17825                                 Waving       WaveType
17826                                 ConnectSides uint8
17827                                 ConnectTo    []Content
17828                                 InsideTint   color.NRGBA
17829                                 Level        uint8 // Must be < 128.
17830
17831                                 Translucent bool // Sunlight is scattered and becomes normal light.
17832                                 Transparent bool // Sunlight isn't scattered.
17833                                 LightSrc    uint8
17834
17835                                 GndContent   bool
17836                                 Collides     bool
17837                                 Pointable    bool
17838                                 Diggable     bool
17839                                 Climbable    bool
17840                                 Replaceable  bool
17841                                 OnRightClick bool
17842
17843                                 DmgPerSec int32
17844
17845                                 LiquidType   LiquidType
17846                                 FlowingAlt   string
17847                                 SrcAlt       string
17848                                 Viscosity    uint8 // 0-7
17849                                 LiqRenewable bool
17850                                 FlowRange    uint8
17851                                 DrownDmg     uint8
17852                                 Floodable    bool
17853
17854                                 DrawBox, ColBox, SelBox NodeBox
17855
17856                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17857
17858                                 LegacyFaceDir bool
17859                                 LegacyMounted bool
17860
17861                                 DigPredict string
17862
17863                                 MaxLvl uint8
17864
17865                                 AlphaUse
17866                         }))(obj)).DiggingSnd).serialize(w)
17867                 }); err != nil {
17868                         if err == io.EOF {
17869                                 chk(io.EOF)
17870                         }
17871                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
17872                 }
17873                 if err := pcall(func() {
17874                         ((*(*(struct {
17875                                 Param0 Content
17876
17877                                 Name   string
17878                                 Groups []Group
17879
17880                                 P1Type   Param1Type
17881                                 P2Type   Param2Type
17882                                 DrawType DrawType
17883
17884                                 Mesh  string
17885                                 Scale float32
17886                                 //mt:const uint8(6)
17887                                 Tiles        [6]TileDef
17888                                 OverlayTiles [6]TileDef
17889                                 //mt:const uint8(6)
17890                                 SpecialTiles [6]TileDef
17891
17892                                 Color   color.NRGBA
17893                                 Palette Texture
17894
17895                                 Waving       WaveType
17896                                 ConnectSides uint8
17897                                 ConnectTo    []Content
17898                                 InsideTint   color.NRGBA
17899                                 Level        uint8 // Must be < 128.
17900
17901                                 Translucent bool // Sunlight is scattered and becomes normal light.
17902                                 Transparent bool // Sunlight isn't scattered.
17903                                 LightSrc    uint8
17904
17905                                 GndContent   bool
17906                                 Collides     bool
17907                                 Pointable    bool
17908                                 Diggable     bool
17909                                 Climbable    bool
17910                                 Replaceable  bool
17911                                 OnRightClick bool
17912
17913                                 DmgPerSec int32
17914
17915                                 LiquidType   LiquidType
17916                                 FlowingAlt   string
17917                                 SrcAlt       string
17918                                 Viscosity    uint8 // 0-7
17919                                 LiqRenewable bool
17920                                 FlowRange    uint8
17921                                 DrownDmg     uint8
17922                                 Floodable    bool
17923
17924                                 DrawBox, ColBox, SelBox NodeBox
17925
17926                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17927
17928                                 LegacyFaceDir bool
17929                                 LegacyMounted bool
17930
17931                                 DigPredict string
17932
17933                                 MaxLvl uint8
17934
17935                                 AlphaUse
17936                         }))(obj)).DugSnd).serialize(w)
17937                 }); err != nil {
17938                         if err == io.EOF {
17939                                 chk(io.EOF)
17940                         }
17941                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
17942                 }
17943                 {
17944                         x := (*(*(struct {
17945                                 Param0 Content
17946
17947                                 Name   string
17948                                 Groups []Group
17949
17950                                 P1Type   Param1Type
17951                                 P2Type   Param2Type
17952                                 DrawType DrawType
17953
17954                                 Mesh  string
17955                                 Scale float32
17956                                 //mt:const uint8(6)
17957                                 Tiles        [6]TileDef
17958                                 OverlayTiles [6]TileDef
17959                                 //mt:const uint8(6)
17960                                 SpecialTiles [6]TileDef
17961
17962                                 Color   color.NRGBA
17963                                 Palette Texture
17964
17965                                 Waving       WaveType
17966                                 ConnectSides uint8
17967                                 ConnectTo    []Content
17968                                 InsideTint   color.NRGBA
17969                                 Level        uint8 // Must be < 128.
17970
17971                                 Translucent bool // Sunlight is scattered and becomes normal light.
17972                                 Transparent bool // Sunlight isn't scattered.
17973                                 LightSrc    uint8
17974
17975                                 GndContent   bool
17976                                 Collides     bool
17977                                 Pointable    bool
17978                                 Diggable     bool
17979                                 Climbable    bool
17980                                 Replaceable  bool
17981                                 OnRightClick bool
17982
17983                                 DmgPerSec int32
17984
17985                                 LiquidType   LiquidType
17986                                 FlowingAlt   string
17987                                 SrcAlt       string
17988                                 Viscosity    uint8 // 0-7
17989                                 LiqRenewable bool
17990                                 FlowRange    uint8
17991                                 DrownDmg     uint8
17992                                 Floodable    bool
17993
17994                                 DrawBox, ColBox, SelBox NodeBox
17995
17996                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17997
17998                                 LegacyFaceDir bool
17999                                 LegacyMounted bool
18000
18001                                 DigPredict string
18002
18003                                 MaxLvl uint8
18004
18005                                 AlphaUse
18006                         }))(obj)).LegacyFaceDir
18007                         if x {
18008                                 write8(w, 1)
18009                         } else {
18010                                 write8(w, 0)
18011                         }
18012
18013                 }
18014                 {
18015                         x := (*(*(struct {
18016                                 Param0 Content
18017
18018                                 Name   string
18019                                 Groups []Group
18020
18021                                 P1Type   Param1Type
18022                                 P2Type   Param2Type
18023                                 DrawType DrawType
18024
18025                                 Mesh  string
18026                                 Scale float32
18027                                 //mt:const uint8(6)
18028                                 Tiles        [6]TileDef
18029                                 OverlayTiles [6]TileDef
18030                                 //mt:const uint8(6)
18031                                 SpecialTiles [6]TileDef
18032
18033                                 Color   color.NRGBA
18034                                 Palette Texture
18035
18036                                 Waving       WaveType
18037                                 ConnectSides uint8
18038                                 ConnectTo    []Content
18039                                 InsideTint   color.NRGBA
18040                                 Level        uint8 // Must be < 128.
18041
18042                                 Translucent bool // Sunlight is scattered and becomes normal light.
18043                                 Transparent bool // Sunlight isn't scattered.
18044                                 LightSrc    uint8
18045
18046                                 GndContent   bool
18047                                 Collides     bool
18048                                 Pointable    bool
18049                                 Diggable     bool
18050                                 Climbable    bool
18051                                 Replaceable  bool
18052                                 OnRightClick bool
18053
18054                                 DmgPerSec int32
18055
18056                                 LiquidType   LiquidType
18057                                 FlowingAlt   string
18058                                 SrcAlt       string
18059                                 Viscosity    uint8 // 0-7
18060                                 LiqRenewable bool
18061                                 FlowRange    uint8
18062                                 DrownDmg     uint8
18063                                 Floodable    bool
18064
18065                                 DrawBox, ColBox, SelBox NodeBox
18066
18067                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18068
18069                                 LegacyFaceDir bool
18070                                 LegacyMounted bool
18071
18072                                 DigPredict string
18073
18074                                 MaxLvl uint8
18075
18076                                 AlphaUse
18077                         }))(obj)).LegacyMounted
18078                         if x {
18079                                 write8(w, 1)
18080                         } else {
18081                                 write8(w, 0)
18082                         }
18083
18084                 }
18085                 if len(([]byte((*(*(struct {
18086                         Param0 Content
18087
18088                         Name   string
18089                         Groups []Group
18090
18091                         P1Type   Param1Type
18092                         P2Type   Param2Type
18093                         DrawType DrawType
18094
18095                         Mesh  string
18096                         Scale float32
18097                         //mt:const uint8(6)
18098                         Tiles        [6]TileDef
18099                         OverlayTiles [6]TileDef
18100                         //mt:const uint8(6)
18101                         SpecialTiles [6]TileDef
18102
18103                         Color   color.NRGBA
18104                         Palette Texture
18105
18106                         Waving       WaveType
18107                         ConnectSides uint8
18108                         ConnectTo    []Content
18109                         InsideTint   color.NRGBA
18110                         Level        uint8 // Must be < 128.
18111
18112                         Translucent bool // Sunlight is scattered and becomes normal light.
18113                         Transparent bool // Sunlight isn't scattered.
18114                         LightSrc    uint8
18115
18116                         GndContent   bool
18117                         Collides     bool
18118                         Pointable    bool
18119                         Diggable     bool
18120                         Climbable    bool
18121                         Replaceable  bool
18122                         OnRightClick bool
18123
18124                         DmgPerSec int32
18125
18126                         LiquidType   LiquidType
18127                         FlowingAlt   string
18128                         SrcAlt       string
18129                         Viscosity    uint8 // 0-7
18130                         LiqRenewable bool
18131                         FlowRange    uint8
18132                         DrownDmg     uint8
18133                         Floodable    bool
18134
18135                         DrawBox, ColBox, SelBox NodeBox
18136
18137                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18138
18139                         LegacyFaceDir bool
18140                         LegacyMounted bool
18141
18142                         DigPredict string
18143
18144                         MaxLvl uint8
18145
18146                         AlphaUse
18147                 }))(obj)).DigPredict))) > math.MaxUint16 {
18148                         chk(ErrTooLong)
18149                 }
18150                 {
18151                         x := uint16(len(([]byte((*(*(struct {
18152                                 Param0 Content
18153
18154                                 Name   string
18155                                 Groups []Group
18156
18157                                 P1Type   Param1Type
18158                                 P2Type   Param2Type
18159                                 DrawType DrawType
18160
18161                                 Mesh  string
18162                                 Scale float32
18163                                 //mt:const uint8(6)
18164                                 Tiles        [6]TileDef
18165                                 OverlayTiles [6]TileDef
18166                                 //mt:const uint8(6)
18167                                 SpecialTiles [6]TileDef
18168
18169                                 Color   color.NRGBA
18170                                 Palette Texture
18171
18172                                 Waving       WaveType
18173                                 ConnectSides uint8
18174                                 ConnectTo    []Content
18175                                 InsideTint   color.NRGBA
18176                                 Level        uint8 // Must be < 128.
18177
18178                                 Translucent bool // Sunlight is scattered and becomes normal light.
18179                                 Transparent bool // Sunlight isn't scattered.
18180                                 LightSrc    uint8
18181
18182                                 GndContent   bool
18183                                 Collides     bool
18184                                 Pointable    bool
18185                                 Diggable     bool
18186                                 Climbable    bool
18187                                 Replaceable  bool
18188                                 OnRightClick bool
18189
18190                                 DmgPerSec int32
18191
18192                                 LiquidType   LiquidType
18193                                 FlowingAlt   string
18194                                 SrcAlt       string
18195                                 Viscosity    uint8 // 0-7
18196                                 LiqRenewable bool
18197                                 FlowRange    uint8
18198                                 DrownDmg     uint8
18199                                 Floodable    bool
18200
18201                                 DrawBox, ColBox, SelBox NodeBox
18202
18203                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18204
18205                                 LegacyFaceDir bool
18206                                 LegacyMounted bool
18207
18208                                 DigPredict string
18209
18210                                 MaxLvl uint8
18211
18212                                 AlphaUse
18213                         }))(obj)).DigPredict))))
18214                         write16(w, uint16(x))
18215                 }
18216                 {
18217                         _, err := w.Write(([]byte((*(*(struct {
18218                                 Param0 Content
18219
18220                                 Name   string
18221                                 Groups []Group
18222
18223                                 P1Type   Param1Type
18224                                 P2Type   Param2Type
18225                                 DrawType DrawType
18226
18227                                 Mesh  string
18228                                 Scale float32
18229                                 //mt:const uint8(6)
18230                                 Tiles        [6]TileDef
18231                                 OverlayTiles [6]TileDef
18232                                 //mt:const uint8(6)
18233                                 SpecialTiles [6]TileDef
18234
18235                                 Color   color.NRGBA
18236                                 Palette Texture
18237
18238                                 Waving       WaveType
18239                                 ConnectSides uint8
18240                                 ConnectTo    []Content
18241                                 InsideTint   color.NRGBA
18242                                 Level        uint8 // Must be < 128.
18243
18244                                 Translucent bool // Sunlight is scattered and becomes normal light.
18245                                 Transparent bool // Sunlight isn't scattered.
18246                                 LightSrc    uint8
18247
18248                                 GndContent   bool
18249                                 Collides     bool
18250                                 Pointable    bool
18251                                 Diggable     bool
18252                                 Climbable    bool
18253                                 Replaceable  bool
18254                                 OnRightClick bool
18255
18256                                 DmgPerSec int32
18257
18258                                 LiquidType   LiquidType
18259                                 FlowingAlt   string
18260                                 SrcAlt       string
18261                                 Viscosity    uint8 // 0-7
18262                                 LiqRenewable bool
18263                                 FlowRange    uint8
18264                                 DrownDmg     uint8
18265                                 Floodable    bool
18266
18267                                 DrawBox, ColBox, SelBox NodeBox
18268
18269                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18270
18271                                 LegacyFaceDir bool
18272                                 LegacyMounted bool
18273
18274                                 DigPredict string
18275
18276                                 MaxLvl uint8
18277
18278                                 AlphaUse
18279                         }))(obj)).DigPredict))[:])
18280                         chk(err)
18281                 }
18282                 {
18283                         x := (*(*(struct {
18284                                 Param0 Content
18285
18286                                 Name   string
18287                                 Groups []Group
18288
18289                                 P1Type   Param1Type
18290                                 P2Type   Param2Type
18291                                 DrawType DrawType
18292
18293                                 Mesh  string
18294                                 Scale float32
18295                                 //mt:const uint8(6)
18296                                 Tiles        [6]TileDef
18297                                 OverlayTiles [6]TileDef
18298                                 //mt:const uint8(6)
18299                                 SpecialTiles [6]TileDef
18300
18301                                 Color   color.NRGBA
18302                                 Palette Texture
18303
18304                                 Waving       WaveType
18305                                 ConnectSides uint8
18306                                 ConnectTo    []Content
18307                                 InsideTint   color.NRGBA
18308                                 Level        uint8 // Must be < 128.
18309
18310                                 Translucent bool // Sunlight is scattered and becomes normal light.
18311                                 Transparent bool // Sunlight isn't scattered.
18312                                 LightSrc    uint8
18313
18314                                 GndContent   bool
18315                                 Collides     bool
18316                                 Pointable    bool
18317                                 Diggable     bool
18318                                 Climbable    bool
18319                                 Replaceable  bool
18320                                 OnRightClick bool
18321
18322                                 DmgPerSec int32
18323
18324                                 LiquidType   LiquidType
18325                                 FlowingAlt   string
18326                                 SrcAlt       string
18327                                 Viscosity    uint8 // 0-7
18328                                 LiqRenewable bool
18329                                 FlowRange    uint8
18330                                 DrownDmg     uint8
18331                                 Floodable    bool
18332
18333                                 DrawBox, ColBox, SelBox NodeBox
18334
18335                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18336
18337                                 LegacyFaceDir bool
18338                                 LegacyMounted bool
18339
18340                                 DigPredict string
18341
18342                                 MaxLvl uint8
18343
18344                                 AlphaUse
18345                         }))(obj)).MaxLvl
18346                         write8(w, uint8(x))
18347                 }
18348                 if err := pcall(func() {
18349                         ((*(*(struct {
18350                                 Param0 Content
18351
18352                                 Name   string
18353                                 Groups []Group
18354
18355                                 P1Type   Param1Type
18356                                 P2Type   Param2Type
18357                                 DrawType DrawType
18358
18359                                 Mesh  string
18360                                 Scale float32
18361                                 //mt:const uint8(6)
18362                                 Tiles        [6]TileDef
18363                                 OverlayTiles [6]TileDef
18364                                 //mt:const uint8(6)
18365                                 SpecialTiles [6]TileDef
18366
18367                                 Color   color.NRGBA
18368                                 Palette Texture
18369
18370                                 Waving       WaveType
18371                                 ConnectSides uint8
18372                                 ConnectTo    []Content
18373                                 InsideTint   color.NRGBA
18374                                 Level        uint8 // Must be < 128.
18375
18376                                 Translucent bool // Sunlight is scattered and becomes normal light.
18377                                 Transparent bool // Sunlight isn't scattered.
18378                                 LightSrc    uint8
18379
18380                                 GndContent   bool
18381                                 Collides     bool
18382                                 Pointable    bool
18383                                 Diggable     bool
18384                                 Climbable    bool
18385                                 Replaceable  bool
18386                                 OnRightClick bool
18387
18388                                 DmgPerSec int32
18389
18390                                 LiquidType   LiquidType
18391                                 FlowingAlt   string
18392                                 SrcAlt       string
18393                                 Viscosity    uint8 // 0-7
18394                                 LiqRenewable bool
18395                                 FlowRange    uint8
18396                                 DrownDmg     uint8
18397                                 Floodable    bool
18398
18399                                 DrawBox, ColBox, SelBox NodeBox
18400
18401                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18402
18403                                 LegacyFaceDir bool
18404                                 LegacyMounted bool
18405
18406                                 DigPredict string
18407
18408                                 MaxLvl uint8
18409
18410                                 AlphaUse
18411                         }))(obj)).AlphaUse).serialize(w)
18412                 }); err != nil {
18413                         if err == io.EOF {
18414                                 chk(io.EOF)
18415                         }
18416                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlphaUse", err))
18417                 }
18418                 {
18419                         buf := w
18420                         w := ow
18421                         if len((buf.Bytes())) > math.MaxUint16 {
18422                                 chk(ErrTooLong)
18423                         }
18424                         {
18425                                 x := uint16(len((buf.Bytes())))
18426                                 write16(w, uint16(x))
18427                         }
18428                         {
18429                                 _, err := w.Write((buf.Bytes())[:])
18430                                 chk(err)
18431                         }
18432                 }
18433         }
18434 }
18435
18436 func (obj *NodeDef) deserialize(r io.Reader) {
18437         if err := pcall(func() {
18438                 ((*(*(struct {
18439                         Param0 Content
18440
18441                         Name   string
18442                         Groups []Group
18443
18444                         P1Type   Param1Type
18445                         P2Type   Param2Type
18446                         DrawType DrawType
18447
18448                         Mesh  string
18449                         Scale float32
18450                         //mt:const uint8(6)
18451                         Tiles        [6]TileDef
18452                         OverlayTiles [6]TileDef
18453                         //mt:const uint8(6)
18454                         SpecialTiles [6]TileDef
18455
18456                         Color   color.NRGBA
18457                         Palette Texture
18458
18459                         Waving       WaveType
18460                         ConnectSides uint8
18461                         ConnectTo    []Content
18462                         InsideTint   color.NRGBA
18463                         Level        uint8 // Must be < 128.
18464
18465                         Translucent bool // Sunlight is scattered and becomes normal light.
18466                         Transparent bool // Sunlight isn't scattered.
18467                         LightSrc    uint8
18468
18469                         GndContent   bool
18470                         Collides     bool
18471                         Pointable    bool
18472                         Diggable     bool
18473                         Climbable    bool
18474                         Replaceable  bool
18475                         OnRightClick bool
18476
18477                         DmgPerSec int32
18478
18479                         LiquidType   LiquidType
18480                         FlowingAlt   string
18481                         SrcAlt       string
18482                         Viscosity    uint8 // 0-7
18483                         LiqRenewable bool
18484                         FlowRange    uint8
18485                         DrownDmg     uint8
18486                         Floodable    bool
18487
18488                         DrawBox, ColBox, SelBox NodeBox
18489
18490                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18491
18492                         LegacyFaceDir bool
18493                         LegacyMounted bool
18494
18495                         DigPredict string
18496
18497                         MaxLvl uint8
18498
18499                         AlphaUse
18500                 }))(obj)).Param0).deserialize(r)
18501         }); err != nil {
18502                 if err == io.EOF {
18503                         chk(io.EOF)
18504                 }
18505                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
18506         }
18507         {
18508                 var n uint16
18509                 {
18510                         p := &n
18511                         *p = read16(r)
18512                 }
18513                 r := &io.LimitedReader{R: r, N: int64(n)}
18514                 {
18515                         var local246 uint8
18516                         local247 := uint8(13)
18517                         {
18518                                 p := &local246
18519                                 *p = read8(r)
18520                         }
18521                         if local246 != local247 {
18522                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
18523                         }
18524                 }
18525                 var local248 []uint8
18526                 var local249 uint16
18527                 {
18528                         p := &local249
18529                         *p = read16(r)
18530                 }
18531                 (local248) = make([]uint8, local249)
18532                 {
18533                         _, err := io.ReadFull(r, (local248)[:])
18534                         chk(err)
18535                 }
18536                 ((*(*(struct {
18537                         Param0 Content
18538
18539                         Name   string
18540                         Groups []Group
18541
18542                         P1Type   Param1Type
18543                         P2Type   Param2Type
18544                         DrawType DrawType
18545
18546                         Mesh  string
18547                         Scale float32
18548                         //mt:const uint8(6)
18549                         Tiles        [6]TileDef
18550                         OverlayTiles [6]TileDef
18551                         //mt:const uint8(6)
18552                         SpecialTiles [6]TileDef
18553
18554                         Color   color.NRGBA
18555                         Palette Texture
18556
18557                         Waving       WaveType
18558                         ConnectSides uint8
18559                         ConnectTo    []Content
18560                         InsideTint   color.NRGBA
18561                         Level        uint8 // Must be < 128.
18562
18563                         Translucent bool // Sunlight is scattered and becomes normal light.
18564                         Transparent bool // Sunlight isn't scattered.
18565                         LightSrc    uint8
18566
18567                         GndContent   bool
18568                         Collides     bool
18569                         Pointable    bool
18570                         Diggable     bool
18571                         Climbable    bool
18572                         Replaceable  bool
18573                         OnRightClick bool
18574
18575                         DmgPerSec int32
18576
18577                         LiquidType   LiquidType
18578                         FlowingAlt   string
18579                         SrcAlt       string
18580                         Viscosity    uint8 // 0-7
18581                         LiqRenewable bool
18582                         FlowRange    uint8
18583                         DrownDmg     uint8
18584                         Floodable    bool
18585
18586                         DrawBox, ColBox, SelBox NodeBox
18587
18588                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18589
18590                         LegacyFaceDir bool
18591                         LegacyMounted bool
18592
18593                         DigPredict string
18594
18595                         MaxLvl uint8
18596
18597                         AlphaUse
18598                 }))(obj)).Name) = string(local248)
18599                 var local250 uint16
18600                 {
18601                         p := &local250
18602                         *p = read16(r)
18603                 }
18604                 ((*(*(struct {
18605                         Param0 Content
18606
18607                         Name   string
18608                         Groups []Group
18609
18610                         P1Type   Param1Type
18611                         P2Type   Param2Type
18612                         DrawType DrawType
18613
18614                         Mesh  string
18615                         Scale float32
18616                         //mt:const uint8(6)
18617                         Tiles        [6]TileDef
18618                         OverlayTiles [6]TileDef
18619                         //mt:const uint8(6)
18620                         SpecialTiles [6]TileDef
18621
18622                         Color   color.NRGBA
18623                         Palette Texture
18624
18625                         Waving       WaveType
18626                         ConnectSides uint8
18627                         ConnectTo    []Content
18628                         InsideTint   color.NRGBA
18629                         Level        uint8 // Must be < 128.
18630
18631                         Translucent bool // Sunlight is scattered and becomes normal light.
18632                         Transparent bool // Sunlight isn't scattered.
18633                         LightSrc    uint8
18634
18635                         GndContent   bool
18636                         Collides     bool
18637                         Pointable    bool
18638                         Diggable     bool
18639                         Climbable    bool
18640                         Replaceable  bool
18641                         OnRightClick bool
18642
18643                         DmgPerSec int32
18644
18645                         LiquidType   LiquidType
18646                         FlowingAlt   string
18647                         SrcAlt       string
18648                         Viscosity    uint8 // 0-7
18649                         LiqRenewable bool
18650                         FlowRange    uint8
18651                         DrownDmg     uint8
18652                         Floodable    bool
18653
18654                         DrawBox, ColBox, SelBox NodeBox
18655
18656                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18657
18658                         LegacyFaceDir bool
18659                         LegacyMounted bool
18660
18661                         DigPredict string
18662
18663                         MaxLvl uint8
18664
18665                         AlphaUse
18666                 }))(obj)).Groups) = make([]Group, local250)
18667                 for local251 := range (*(*(struct {
18668                         Param0 Content
18669
18670                         Name   string
18671                         Groups []Group
18672
18673                         P1Type   Param1Type
18674                         P2Type   Param2Type
18675                         DrawType DrawType
18676
18677                         Mesh  string
18678                         Scale float32
18679                         //mt:const uint8(6)
18680                         Tiles        [6]TileDef
18681                         OverlayTiles [6]TileDef
18682                         //mt:const uint8(6)
18683                         SpecialTiles [6]TileDef
18684
18685                         Color   color.NRGBA
18686                         Palette Texture
18687
18688                         Waving       WaveType
18689                         ConnectSides uint8
18690                         ConnectTo    []Content
18691                         InsideTint   color.NRGBA
18692                         Level        uint8 // Must be < 128.
18693
18694                         Translucent bool // Sunlight is scattered and becomes normal light.
18695                         Transparent bool // Sunlight isn't scattered.
18696                         LightSrc    uint8
18697
18698                         GndContent   bool
18699                         Collides     bool
18700                         Pointable    bool
18701                         Diggable     bool
18702                         Climbable    bool
18703                         Replaceable  bool
18704                         OnRightClick bool
18705
18706                         DmgPerSec int32
18707
18708                         LiquidType   LiquidType
18709                         FlowingAlt   string
18710                         SrcAlt       string
18711                         Viscosity    uint8 // 0-7
18712                         LiqRenewable bool
18713                         FlowRange    uint8
18714                         DrownDmg     uint8
18715                         Floodable    bool
18716
18717                         DrawBox, ColBox, SelBox NodeBox
18718
18719                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18720
18721                         LegacyFaceDir bool
18722                         LegacyMounted bool
18723
18724                         DigPredict string
18725
18726                         MaxLvl uint8
18727
18728                         AlphaUse
18729                 }))(obj)).Groups {
18730                         if err := pcall(func() {
18731                                 (((*(*(struct {
18732                                         Param0 Content
18733
18734                                         Name   string
18735                                         Groups []Group
18736
18737                                         P1Type   Param1Type
18738                                         P2Type   Param2Type
18739                                         DrawType DrawType
18740
18741                                         Mesh  string
18742                                         Scale float32
18743                                         //mt:const uint8(6)
18744                                         Tiles        [6]TileDef
18745                                         OverlayTiles [6]TileDef
18746                                         //mt:const uint8(6)
18747                                         SpecialTiles [6]TileDef
18748
18749                                         Color   color.NRGBA
18750                                         Palette Texture
18751
18752                                         Waving       WaveType
18753                                         ConnectSides uint8
18754                                         ConnectTo    []Content
18755                                         InsideTint   color.NRGBA
18756                                         Level        uint8 // Must be < 128.
18757
18758                                         Translucent bool // Sunlight is scattered and becomes normal light.
18759                                         Transparent bool // Sunlight isn't scattered.
18760                                         LightSrc    uint8
18761
18762                                         GndContent   bool
18763                                         Collides     bool
18764                                         Pointable    bool
18765                                         Diggable     bool
18766                                         Climbable    bool
18767                                         Replaceable  bool
18768                                         OnRightClick bool
18769
18770                                         DmgPerSec int32
18771
18772                                         LiquidType   LiquidType
18773                                         FlowingAlt   string
18774                                         SrcAlt       string
18775                                         Viscosity    uint8 // 0-7
18776                                         LiqRenewable bool
18777                                         FlowRange    uint8
18778                                         DrownDmg     uint8
18779                                         Floodable    bool
18780
18781                                         DrawBox, ColBox, SelBox NodeBox
18782
18783                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18784
18785                                         LegacyFaceDir bool
18786                                         LegacyMounted bool
18787
18788                                         DigPredict string
18789
18790                                         MaxLvl uint8
18791
18792                                         AlphaUse
18793                                 }))(obj)).Groups)[local251]).deserialize(r)
18794                         }); err != nil {
18795                                 if err == io.EOF {
18796                                         chk(io.EOF)
18797                                 }
18798                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
18799                         }
18800                 }
18801                 if err := pcall(func() {
18802                         ((*(*(struct {
18803                                 Param0 Content
18804
18805                                 Name   string
18806                                 Groups []Group
18807
18808                                 P1Type   Param1Type
18809                                 P2Type   Param2Type
18810                                 DrawType DrawType
18811
18812                                 Mesh  string
18813                                 Scale float32
18814                                 //mt:const uint8(6)
18815                                 Tiles        [6]TileDef
18816                                 OverlayTiles [6]TileDef
18817                                 //mt:const uint8(6)
18818                                 SpecialTiles [6]TileDef
18819
18820                                 Color   color.NRGBA
18821                                 Palette Texture
18822
18823                                 Waving       WaveType
18824                                 ConnectSides uint8
18825                                 ConnectTo    []Content
18826                                 InsideTint   color.NRGBA
18827                                 Level        uint8 // Must be < 128.
18828
18829                                 Translucent bool // Sunlight is scattered and becomes normal light.
18830                                 Transparent bool // Sunlight isn't scattered.
18831                                 LightSrc    uint8
18832
18833                                 GndContent   bool
18834                                 Collides     bool
18835                                 Pointable    bool
18836                                 Diggable     bool
18837                                 Climbable    bool
18838                                 Replaceable  bool
18839                                 OnRightClick bool
18840
18841                                 DmgPerSec int32
18842
18843                                 LiquidType   LiquidType
18844                                 FlowingAlt   string
18845                                 SrcAlt       string
18846                                 Viscosity    uint8 // 0-7
18847                                 LiqRenewable bool
18848                                 FlowRange    uint8
18849                                 DrownDmg     uint8
18850                                 Floodable    bool
18851
18852                                 DrawBox, ColBox, SelBox NodeBox
18853
18854                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18855
18856                                 LegacyFaceDir bool
18857                                 LegacyMounted bool
18858
18859                                 DigPredict string
18860
18861                                 MaxLvl uint8
18862
18863                                 AlphaUse
18864                         }))(obj)).P1Type).deserialize(r)
18865                 }); err != nil {
18866                         if err == io.EOF {
18867                                 chk(io.EOF)
18868                         }
18869                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param1Type", err))
18870                 }
18871                 if err := pcall(func() {
18872                         ((*(*(struct {
18873                                 Param0 Content
18874
18875                                 Name   string
18876                                 Groups []Group
18877
18878                                 P1Type   Param1Type
18879                                 P2Type   Param2Type
18880                                 DrawType DrawType
18881
18882                                 Mesh  string
18883                                 Scale float32
18884                                 //mt:const uint8(6)
18885                                 Tiles        [6]TileDef
18886                                 OverlayTiles [6]TileDef
18887                                 //mt:const uint8(6)
18888                                 SpecialTiles [6]TileDef
18889
18890                                 Color   color.NRGBA
18891                                 Palette Texture
18892
18893                                 Waving       WaveType
18894                                 ConnectSides uint8
18895                                 ConnectTo    []Content
18896                                 InsideTint   color.NRGBA
18897                                 Level        uint8 // Must be < 128.
18898
18899                                 Translucent bool // Sunlight is scattered and becomes normal light.
18900                                 Transparent bool // Sunlight isn't scattered.
18901                                 LightSrc    uint8
18902
18903                                 GndContent   bool
18904                                 Collides     bool
18905                                 Pointable    bool
18906                                 Diggable     bool
18907                                 Climbable    bool
18908                                 Replaceable  bool
18909                                 OnRightClick bool
18910
18911                                 DmgPerSec int32
18912
18913                                 LiquidType   LiquidType
18914                                 FlowingAlt   string
18915                                 SrcAlt       string
18916                                 Viscosity    uint8 // 0-7
18917                                 LiqRenewable bool
18918                                 FlowRange    uint8
18919                                 DrownDmg     uint8
18920                                 Floodable    bool
18921
18922                                 DrawBox, ColBox, SelBox NodeBox
18923
18924                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18925
18926                                 LegacyFaceDir bool
18927                                 LegacyMounted bool
18928
18929                                 DigPredict string
18930
18931                                 MaxLvl uint8
18932
18933                                 AlphaUse
18934                         }))(obj)).P2Type).deserialize(r)
18935                 }); err != nil {
18936                         if err == io.EOF {
18937                                 chk(io.EOF)
18938                         }
18939                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Param2Type", err))
18940                 }
18941                 if err := pcall(func() {
18942                         ((*(*(struct {
18943                                 Param0 Content
18944
18945                                 Name   string
18946                                 Groups []Group
18947
18948                                 P1Type   Param1Type
18949                                 P2Type   Param2Type
18950                                 DrawType DrawType
18951
18952                                 Mesh  string
18953                                 Scale float32
18954                                 //mt:const uint8(6)
18955                                 Tiles        [6]TileDef
18956                                 OverlayTiles [6]TileDef
18957                                 //mt:const uint8(6)
18958                                 SpecialTiles [6]TileDef
18959
18960                                 Color   color.NRGBA
18961                                 Palette Texture
18962
18963                                 Waving       WaveType
18964                                 ConnectSides uint8
18965                                 ConnectTo    []Content
18966                                 InsideTint   color.NRGBA
18967                                 Level        uint8 // Must be < 128.
18968
18969                                 Translucent bool // Sunlight is scattered and becomes normal light.
18970                                 Transparent bool // Sunlight isn't scattered.
18971                                 LightSrc    uint8
18972
18973                                 GndContent   bool
18974                                 Collides     bool
18975                                 Pointable    bool
18976                                 Diggable     bool
18977                                 Climbable    bool
18978                                 Replaceable  bool
18979                                 OnRightClick bool
18980
18981                                 DmgPerSec int32
18982
18983                                 LiquidType   LiquidType
18984                                 FlowingAlt   string
18985                                 SrcAlt       string
18986                                 Viscosity    uint8 // 0-7
18987                                 LiqRenewable bool
18988                                 FlowRange    uint8
18989                                 DrownDmg     uint8
18990                                 Floodable    bool
18991
18992                                 DrawBox, ColBox, SelBox NodeBox
18993
18994                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18995
18996                                 LegacyFaceDir bool
18997                                 LegacyMounted bool
18998
18999                                 DigPredict string
19000
19001                                 MaxLvl uint8
19002
19003                                 AlphaUse
19004                         }))(obj)).DrawType).deserialize(r)
19005                 }); err != nil {
19006                         if err == io.EOF {
19007                                 chk(io.EOF)
19008                         }
19009                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DrawType", err))
19010                 }
19011                 var local252 []uint8
19012                 var local253 uint16
19013                 {
19014                         p := &local253
19015                         *p = read16(r)
19016                 }
19017                 (local252) = make([]uint8, local253)
19018                 {
19019                         _, err := io.ReadFull(r, (local252)[:])
19020                         chk(err)
19021                 }
19022                 ((*(*(struct {
19023                         Param0 Content
19024
19025                         Name   string
19026                         Groups []Group
19027
19028                         P1Type   Param1Type
19029                         P2Type   Param2Type
19030                         DrawType DrawType
19031
19032                         Mesh  string
19033                         Scale float32
19034                         //mt:const uint8(6)
19035                         Tiles        [6]TileDef
19036                         OverlayTiles [6]TileDef
19037                         //mt:const uint8(6)
19038                         SpecialTiles [6]TileDef
19039
19040                         Color   color.NRGBA
19041                         Palette Texture
19042
19043                         Waving       WaveType
19044                         ConnectSides uint8
19045                         ConnectTo    []Content
19046                         InsideTint   color.NRGBA
19047                         Level        uint8 // Must be < 128.
19048
19049                         Translucent bool // Sunlight is scattered and becomes normal light.
19050                         Transparent bool // Sunlight isn't scattered.
19051                         LightSrc    uint8
19052
19053                         GndContent   bool
19054                         Collides     bool
19055                         Pointable    bool
19056                         Diggable     bool
19057                         Climbable    bool
19058                         Replaceable  bool
19059                         OnRightClick bool
19060
19061                         DmgPerSec int32
19062
19063                         LiquidType   LiquidType
19064                         FlowingAlt   string
19065                         SrcAlt       string
19066                         Viscosity    uint8 // 0-7
19067                         LiqRenewable bool
19068                         FlowRange    uint8
19069                         DrownDmg     uint8
19070                         Floodable    bool
19071
19072                         DrawBox, ColBox, SelBox NodeBox
19073
19074                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19075
19076                         LegacyFaceDir bool
19077                         LegacyMounted bool
19078
19079                         DigPredict string
19080
19081                         MaxLvl uint8
19082
19083                         AlphaUse
19084                 }))(obj)).Mesh) = string(local252)
19085                 {
19086                         p := &(*(*(struct {
19087                                 Param0 Content
19088
19089                                 Name   string
19090                                 Groups []Group
19091
19092                                 P1Type   Param1Type
19093                                 P2Type   Param2Type
19094                                 DrawType DrawType
19095
19096                                 Mesh  string
19097                                 Scale float32
19098                                 //mt:const uint8(6)
19099                                 Tiles        [6]TileDef
19100                                 OverlayTiles [6]TileDef
19101                                 //mt:const uint8(6)
19102                                 SpecialTiles [6]TileDef
19103
19104                                 Color   color.NRGBA
19105                                 Palette Texture
19106
19107                                 Waving       WaveType
19108                                 ConnectSides uint8
19109                                 ConnectTo    []Content
19110                                 InsideTint   color.NRGBA
19111                                 Level        uint8 // Must be < 128.
19112
19113                                 Translucent bool // Sunlight is scattered and becomes normal light.
19114                                 Transparent bool // Sunlight isn't scattered.
19115                                 LightSrc    uint8
19116
19117                                 GndContent   bool
19118                                 Collides     bool
19119                                 Pointable    bool
19120                                 Diggable     bool
19121                                 Climbable    bool
19122                                 Replaceable  bool
19123                                 OnRightClick bool
19124
19125                                 DmgPerSec int32
19126
19127                                 LiquidType   LiquidType
19128                                 FlowingAlt   string
19129                                 SrcAlt       string
19130                                 Viscosity    uint8 // 0-7
19131                                 LiqRenewable bool
19132                                 FlowRange    uint8
19133                                 DrownDmg     uint8
19134                                 Floodable    bool
19135
19136                                 DrawBox, ColBox, SelBox NodeBox
19137
19138                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19139
19140                                 LegacyFaceDir bool
19141                                 LegacyMounted bool
19142
19143                                 DigPredict string
19144
19145                                 MaxLvl uint8
19146
19147                                 AlphaUse
19148                         }))(obj)).Scale
19149                         *p = math.Float32frombits(read32(r))
19150                 }
19151                 {
19152                         var local254 uint8
19153                         local255 := uint8(6)
19154                         {
19155                                 p := &local254
19156                                 *p = read8(r)
19157                         }
19158                         if local254 != local255 {
19159                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
19160                         }
19161                 }
19162                 for local256 := range (*(*(struct {
19163                         Param0 Content
19164
19165                         Name   string
19166                         Groups []Group
19167
19168                         P1Type   Param1Type
19169                         P2Type   Param2Type
19170                         DrawType DrawType
19171
19172                         Mesh  string
19173                         Scale float32
19174                         //mt:const uint8(6)
19175                         Tiles        [6]TileDef
19176                         OverlayTiles [6]TileDef
19177                         //mt:const uint8(6)
19178                         SpecialTiles [6]TileDef
19179
19180                         Color   color.NRGBA
19181                         Palette Texture
19182
19183                         Waving       WaveType
19184                         ConnectSides uint8
19185                         ConnectTo    []Content
19186                         InsideTint   color.NRGBA
19187                         Level        uint8 // Must be < 128.
19188
19189                         Translucent bool // Sunlight is scattered and becomes normal light.
19190                         Transparent bool // Sunlight isn't scattered.
19191                         LightSrc    uint8
19192
19193                         GndContent   bool
19194                         Collides     bool
19195                         Pointable    bool
19196                         Diggable     bool
19197                         Climbable    bool
19198                         Replaceable  bool
19199                         OnRightClick bool
19200
19201                         DmgPerSec int32
19202
19203                         LiquidType   LiquidType
19204                         FlowingAlt   string
19205                         SrcAlt       string
19206                         Viscosity    uint8 // 0-7
19207                         LiqRenewable bool
19208                         FlowRange    uint8
19209                         DrownDmg     uint8
19210                         Floodable    bool
19211
19212                         DrawBox, ColBox, SelBox NodeBox
19213
19214                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19215
19216                         LegacyFaceDir bool
19217                         LegacyMounted bool
19218
19219                         DigPredict string
19220
19221                         MaxLvl uint8
19222
19223                         AlphaUse
19224                 }))(obj)).Tiles {
19225                         if err := pcall(func() {
19226                                 (((*(*(struct {
19227                                         Param0 Content
19228
19229                                         Name   string
19230                                         Groups []Group
19231
19232                                         P1Type   Param1Type
19233                                         P2Type   Param2Type
19234                                         DrawType DrawType
19235
19236                                         Mesh  string
19237                                         Scale float32
19238                                         //mt:const uint8(6)
19239                                         Tiles        [6]TileDef
19240                                         OverlayTiles [6]TileDef
19241                                         //mt:const uint8(6)
19242                                         SpecialTiles [6]TileDef
19243
19244                                         Color   color.NRGBA
19245                                         Palette Texture
19246
19247                                         Waving       WaveType
19248                                         ConnectSides uint8
19249                                         ConnectTo    []Content
19250                                         InsideTint   color.NRGBA
19251                                         Level        uint8 // Must be < 128.
19252
19253                                         Translucent bool // Sunlight is scattered and becomes normal light.
19254                                         Transparent bool // Sunlight isn't scattered.
19255                                         LightSrc    uint8
19256
19257                                         GndContent   bool
19258                                         Collides     bool
19259                                         Pointable    bool
19260                                         Diggable     bool
19261                                         Climbable    bool
19262                                         Replaceable  bool
19263                                         OnRightClick bool
19264
19265                                         DmgPerSec int32
19266
19267                                         LiquidType   LiquidType
19268                                         FlowingAlt   string
19269                                         SrcAlt       string
19270                                         Viscosity    uint8 // 0-7
19271                                         LiqRenewable bool
19272                                         FlowRange    uint8
19273                                         DrownDmg     uint8
19274                                         Floodable    bool
19275
19276                                         DrawBox, ColBox, SelBox NodeBox
19277
19278                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19279
19280                                         LegacyFaceDir bool
19281                                         LegacyMounted bool
19282
19283                                         DigPredict string
19284
19285                                         MaxLvl uint8
19286
19287                                         AlphaUse
19288                                 }))(obj)).Tiles)[local256]).deserialize(r)
19289                         }); err != nil {
19290                                 if err == io.EOF {
19291                                         chk(io.EOF)
19292                                 }
19293                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
19294                         }
19295                 }
19296                 for local257 := range (*(*(struct {
19297                         Param0 Content
19298
19299                         Name   string
19300                         Groups []Group
19301
19302                         P1Type   Param1Type
19303                         P2Type   Param2Type
19304                         DrawType DrawType
19305
19306                         Mesh  string
19307                         Scale float32
19308                         //mt:const uint8(6)
19309                         Tiles        [6]TileDef
19310                         OverlayTiles [6]TileDef
19311                         //mt:const uint8(6)
19312                         SpecialTiles [6]TileDef
19313
19314                         Color   color.NRGBA
19315                         Palette Texture
19316
19317                         Waving       WaveType
19318                         ConnectSides uint8
19319                         ConnectTo    []Content
19320                         InsideTint   color.NRGBA
19321                         Level        uint8 // Must be < 128.
19322
19323                         Translucent bool // Sunlight is scattered and becomes normal light.
19324                         Transparent bool // Sunlight isn't scattered.
19325                         LightSrc    uint8
19326
19327                         GndContent   bool
19328                         Collides     bool
19329                         Pointable    bool
19330                         Diggable     bool
19331                         Climbable    bool
19332                         Replaceable  bool
19333                         OnRightClick bool
19334
19335                         DmgPerSec int32
19336
19337                         LiquidType   LiquidType
19338                         FlowingAlt   string
19339                         SrcAlt       string
19340                         Viscosity    uint8 // 0-7
19341                         LiqRenewable bool
19342                         FlowRange    uint8
19343                         DrownDmg     uint8
19344                         Floodable    bool
19345
19346                         DrawBox, ColBox, SelBox NodeBox
19347
19348                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19349
19350                         LegacyFaceDir bool
19351                         LegacyMounted bool
19352
19353                         DigPredict string
19354
19355                         MaxLvl uint8
19356
19357                         AlphaUse
19358                 }))(obj)).OverlayTiles {
19359                         if err := pcall(func() {
19360                                 (((*(*(struct {
19361                                         Param0 Content
19362
19363                                         Name   string
19364                                         Groups []Group
19365
19366                                         P1Type   Param1Type
19367                                         P2Type   Param2Type
19368                                         DrawType DrawType
19369
19370                                         Mesh  string
19371                                         Scale float32
19372                                         //mt:const uint8(6)
19373                                         Tiles        [6]TileDef
19374                                         OverlayTiles [6]TileDef
19375                                         //mt:const uint8(6)
19376                                         SpecialTiles [6]TileDef
19377
19378                                         Color   color.NRGBA
19379                                         Palette Texture
19380
19381                                         Waving       WaveType
19382                                         ConnectSides uint8
19383                                         ConnectTo    []Content
19384                                         InsideTint   color.NRGBA
19385                                         Level        uint8 // Must be < 128.
19386
19387                                         Translucent bool // Sunlight is scattered and becomes normal light.
19388                                         Transparent bool // Sunlight isn't scattered.
19389                                         LightSrc    uint8
19390
19391                                         GndContent   bool
19392                                         Collides     bool
19393                                         Pointable    bool
19394                                         Diggable     bool
19395                                         Climbable    bool
19396                                         Replaceable  bool
19397                                         OnRightClick bool
19398
19399                                         DmgPerSec int32
19400
19401                                         LiquidType   LiquidType
19402                                         FlowingAlt   string
19403                                         SrcAlt       string
19404                                         Viscosity    uint8 // 0-7
19405                                         LiqRenewable bool
19406                                         FlowRange    uint8
19407                                         DrownDmg     uint8
19408                                         Floodable    bool
19409
19410                                         DrawBox, ColBox, SelBox NodeBox
19411
19412                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19413
19414                                         LegacyFaceDir bool
19415                                         LegacyMounted bool
19416
19417                                         DigPredict string
19418
19419                                         MaxLvl uint8
19420
19421                                         AlphaUse
19422                                 }))(obj)).OverlayTiles)[local257]).deserialize(r)
19423                         }); err != nil {
19424                                 if err == io.EOF {
19425                                         chk(io.EOF)
19426                                 }
19427                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
19428                         }
19429                 }
19430                 {
19431                         var local258 uint8
19432                         local259 := uint8(6)
19433                         {
19434                                 p := &local258
19435                                 *p = read8(r)
19436                         }
19437                         if local258 != local259 {
19438                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
19439                         }
19440                 }
19441                 for local260 := range (*(*(struct {
19442                         Param0 Content
19443
19444                         Name   string
19445                         Groups []Group
19446
19447                         P1Type   Param1Type
19448                         P2Type   Param2Type
19449                         DrawType DrawType
19450
19451                         Mesh  string
19452                         Scale float32
19453                         //mt:const uint8(6)
19454                         Tiles        [6]TileDef
19455                         OverlayTiles [6]TileDef
19456                         //mt:const uint8(6)
19457                         SpecialTiles [6]TileDef
19458
19459                         Color   color.NRGBA
19460                         Palette Texture
19461
19462                         Waving       WaveType
19463                         ConnectSides uint8
19464                         ConnectTo    []Content
19465                         InsideTint   color.NRGBA
19466                         Level        uint8 // Must be < 128.
19467
19468                         Translucent bool // Sunlight is scattered and becomes normal light.
19469                         Transparent bool // Sunlight isn't scattered.
19470                         LightSrc    uint8
19471
19472                         GndContent   bool
19473                         Collides     bool
19474                         Pointable    bool
19475                         Diggable     bool
19476                         Climbable    bool
19477                         Replaceable  bool
19478                         OnRightClick bool
19479
19480                         DmgPerSec int32
19481
19482                         LiquidType   LiquidType
19483                         FlowingAlt   string
19484                         SrcAlt       string
19485                         Viscosity    uint8 // 0-7
19486                         LiqRenewable bool
19487                         FlowRange    uint8
19488                         DrownDmg     uint8
19489                         Floodable    bool
19490
19491                         DrawBox, ColBox, SelBox NodeBox
19492
19493                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19494
19495                         LegacyFaceDir bool
19496                         LegacyMounted bool
19497
19498                         DigPredict string
19499
19500                         MaxLvl uint8
19501
19502                         AlphaUse
19503                 }))(obj)).SpecialTiles {
19504                         if err := pcall(func() {
19505                                 (((*(*(struct {
19506                                         Param0 Content
19507
19508                                         Name   string
19509                                         Groups []Group
19510
19511                                         P1Type   Param1Type
19512                                         P2Type   Param2Type
19513                                         DrawType DrawType
19514
19515                                         Mesh  string
19516                                         Scale float32
19517                                         //mt:const uint8(6)
19518                                         Tiles        [6]TileDef
19519                                         OverlayTiles [6]TileDef
19520                                         //mt:const uint8(6)
19521                                         SpecialTiles [6]TileDef
19522
19523                                         Color   color.NRGBA
19524                                         Palette Texture
19525
19526                                         Waving       WaveType
19527                                         ConnectSides uint8
19528                                         ConnectTo    []Content
19529                                         InsideTint   color.NRGBA
19530                                         Level        uint8 // Must be < 128.
19531
19532                                         Translucent bool // Sunlight is scattered and becomes normal light.
19533                                         Transparent bool // Sunlight isn't scattered.
19534                                         LightSrc    uint8
19535
19536                                         GndContent   bool
19537                                         Collides     bool
19538                                         Pointable    bool
19539                                         Diggable     bool
19540                                         Climbable    bool
19541                                         Replaceable  bool
19542                                         OnRightClick bool
19543
19544                                         DmgPerSec int32
19545
19546                                         LiquidType   LiquidType
19547                                         FlowingAlt   string
19548                                         SrcAlt       string
19549                                         Viscosity    uint8 // 0-7
19550                                         LiqRenewable bool
19551                                         FlowRange    uint8
19552                                         DrownDmg     uint8
19553                                         Floodable    bool
19554
19555                                         DrawBox, ColBox, SelBox NodeBox
19556
19557                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19558
19559                                         LegacyFaceDir bool
19560                                         LegacyMounted bool
19561
19562                                         DigPredict string
19563
19564                                         MaxLvl uint8
19565
19566                                         AlphaUse
19567                                 }))(obj)).SpecialTiles)[local260]).deserialize(r)
19568                         }); err != nil {
19569                                 if err == io.EOF {
19570                                         chk(io.EOF)
19571                                 }
19572                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileDef", err))
19573                         }
19574                 }
19575                 {
19576                         p := &(*(*(struct {
19577                                 Param0 Content
19578
19579                                 Name   string
19580                                 Groups []Group
19581
19582                                 P1Type   Param1Type
19583                                 P2Type   Param2Type
19584                                 DrawType DrawType
19585
19586                                 Mesh  string
19587                                 Scale float32
19588                                 //mt:const uint8(6)
19589                                 Tiles        [6]TileDef
19590                                 OverlayTiles [6]TileDef
19591                                 //mt:const uint8(6)
19592                                 SpecialTiles [6]TileDef
19593
19594                                 Color   color.NRGBA
19595                                 Palette Texture
19596
19597                                 Waving       WaveType
19598                                 ConnectSides uint8
19599                                 ConnectTo    []Content
19600                                 InsideTint   color.NRGBA
19601                                 Level        uint8 // Must be < 128.
19602
19603                                 Translucent bool // Sunlight is scattered and becomes normal light.
19604                                 Transparent bool // Sunlight isn't scattered.
19605                                 LightSrc    uint8
19606
19607                                 GndContent   bool
19608                                 Collides     bool
19609                                 Pointable    bool
19610                                 Diggable     bool
19611                                 Climbable    bool
19612                                 Replaceable  bool
19613                                 OnRightClick bool
19614
19615                                 DmgPerSec int32
19616
19617                                 LiquidType   LiquidType
19618                                 FlowingAlt   string
19619                                 SrcAlt       string
19620                                 Viscosity    uint8 // 0-7
19621                                 LiqRenewable bool
19622                                 FlowRange    uint8
19623                                 DrownDmg     uint8
19624                                 Floodable    bool
19625
19626                                 DrawBox, ColBox, SelBox NodeBox
19627
19628                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19629
19630                                 LegacyFaceDir bool
19631                                 LegacyMounted bool
19632
19633                                 DigPredict string
19634
19635                                 MaxLvl uint8
19636
19637                                 AlphaUse
19638                         }))(obj)).Color
19639                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
19640
19641                 }
19642                 if err := pcall(func() {
19643                         ((*(*(struct {
19644                                 Param0 Content
19645
19646                                 Name   string
19647                                 Groups []Group
19648
19649                                 P1Type   Param1Type
19650                                 P2Type   Param2Type
19651                                 DrawType DrawType
19652
19653                                 Mesh  string
19654                                 Scale float32
19655                                 //mt:const uint8(6)
19656                                 Tiles        [6]TileDef
19657                                 OverlayTiles [6]TileDef
19658                                 //mt:const uint8(6)
19659                                 SpecialTiles [6]TileDef
19660
19661                                 Color   color.NRGBA
19662                                 Palette Texture
19663
19664                                 Waving       WaveType
19665                                 ConnectSides uint8
19666                                 ConnectTo    []Content
19667                                 InsideTint   color.NRGBA
19668                                 Level        uint8 // Must be < 128.
19669
19670                                 Translucent bool // Sunlight is scattered and becomes normal light.
19671                                 Transparent bool // Sunlight isn't scattered.
19672                                 LightSrc    uint8
19673
19674                                 GndContent   bool
19675                                 Collides     bool
19676                                 Pointable    bool
19677                                 Diggable     bool
19678                                 Climbable    bool
19679                                 Replaceable  bool
19680                                 OnRightClick bool
19681
19682                                 DmgPerSec int32
19683
19684                                 LiquidType   LiquidType
19685                                 FlowingAlt   string
19686                                 SrcAlt       string
19687                                 Viscosity    uint8 // 0-7
19688                                 LiqRenewable bool
19689                                 FlowRange    uint8
19690                                 DrownDmg     uint8
19691                                 Floodable    bool
19692
19693                                 DrawBox, ColBox, SelBox NodeBox
19694
19695                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19696
19697                                 LegacyFaceDir bool
19698                                 LegacyMounted bool
19699
19700                                 DigPredict string
19701
19702                                 MaxLvl uint8
19703
19704                                 AlphaUse
19705                         }))(obj)).Palette).deserialize(r)
19706                 }); err != nil {
19707                         if err == io.EOF {
19708                                 chk(io.EOF)
19709                         }
19710                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
19711                 }
19712                 if err := pcall(func() {
19713                         ((*(*(struct {
19714                                 Param0 Content
19715
19716                                 Name   string
19717                                 Groups []Group
19718
19719                                 P1Type   Param1Type
19720                                 P2Type   Param2Type
19721                                 DrawType DrawType
19722
19723                                 Mesh  string
19724                                 Scale float32
19725                                 //mt:const uint8(6)
19726                                 Tiles        [6]TileDef
19727                                 OverlayTiles [6]TileDef
19728                                 //mt:const uint8(6)
19729                                 SpecialTiles [6]TileDef
19730
19731                                 Color   color.NRGBA
19732                                 Palette Texture
19733
19734                                 Waving       WaveType
19735                                 ConnectSides uint8
19736                                 ConnectTo    []Content
19737                                 InsideTint   color.NRGBA
19738                                 Level        uint8 // Must be < 128.
19739
19740                                 Translucent bool // Sunlight is scattered and becomes normal light.
19741                                 Transparent bool // Sunlight isn't scattered.
19742                                 LightSrc    uint8
19743
19744                                 GndContent   bool
19745                                 Collides     bool
19746                                 Pointable    bool
19747                                 Diggable     bool
19748                                 Climbable    bool
19749                                 Replaceable  bool
19750                                 OnRightClick bool
19751
19752                                 DmgPerSec int32
19753
19754                                 LiquidType   LiquidType
19755                                 FlowingAlt   string
19756                                 SrcAlt       string
19757                                 Viscosity    uint8 // 0-7
19758                                 LiqRenewable bool
19759                                 FlowRange    uint8
19760                                 DrownDmg     uint8
19761                                 Floodable    bool
19762
19763                                 DrawBox, ColBox, SelBox NodeBox
19764
19765                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19766
19767                                 LegacyFaceDir bool
19768                                 LegacyMounted bool
19769
19770                                 DigPredict string
19771
19772                                 MaxLvl uint8
19773
19774                                 AlphaUse
19775                         }))(obj)).Waving).deserialize(r)
19776                 }); err != nil {
19777                         if err == io.EOF {
19778                                 chk(io.EOF)
19779                         }
19780                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.WaveType", err))
19781                 }
19782                 {
19783                         p := &(*(*(struct {
19784                                 Param0 Content
19785
19786                                 Name   string
19787                                 Groups []Group
19788
19789                                 P1Type   Param1Type
19790                                 P2Type   Param2Type
19791                                 DrawType DrawType
19792
19793                                 Mesh  string
19794                                 Scale float32
19795                                 //mt:const uint8(6)
19796                                 Tiles        [6]TileDef
19797                                 OverlayTiles [6]TileDef
19798                                 //mt:const uint8(6)
19799                                 SpecialTiles [6]TileDef
19800
19801                                 Color   color.NRGBA
19802                                 Palette Texture
19803
19804                                 Waving       WaveType
19805                                 ConnectSides uint8
19806                                 ConnectTo    []Content
19807                                 InsideTint   color.NRGBA
19808                                 Level        uint8 // Must be < 128.
19809
19810                                 Translucent bool // Sunlight is scattered and becomes normal light.
19811                                 Transparent bool // Sunlight isn't scattered.
19812                                 LightSrc    uint8
19813
19814                                 GndContent   bool
19815                                 Collides     bool
19816                                 Pointable    bool
19817                                 Diggable     bool
19818                                 Climbable    bool
19819                                 Replaceable  bool
19820                                 OnRightClick bool
19821
19822                                 DmgPerSec int32
19823
19824                                 LiquidType   LiquidType
19825                                 FlowingAlt   string
19826                                 SrcAlt       string
19827                                 Viscosity    uint8 // 0-7
19828                                 LiqRenewable bool
19829                                 FlowRange    uint8
19830                                 DrownDmg     uint8
19831                                 Floodable    bool
19832
19833                                 DrawBox, ColBox, SelBox NodeBox
19834
19835                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19836
19837                                 LegacyFaceDir bool
19838                                 LegacyMounted bool
19839
19840                                 DigPredict string
19841
19842                                 MaxLvl uint8
19843
19844                                 AlphaUse
19845                         }))(obj)).ConnectSides
19846                         *p = read8(r)
19847                 }
19848                 var local261 uint16
19849                 {
19850                         p := &local261
19851                         *p = read16(r)
19852                 }
19853                 ((*(*(struct {
19854                         Param0 Content
19855
19856                         Name   string
19857                         Groups []Group
19858
19859                         P1Type   Param1Type
19860                         P2Type   Param2Type
19861                         DrawType DrawType
19862
19863                         Mesh  string
19864                         Scale float32
19865                         //mt:const uint8(6)
19866                         Tiles        [6]TileDef
19867                         OverlayTiles [6]TileDef
19868                         //mt:const uint8(6)
19869                         SpecialTiles [6]TileDef
19870
19871                         Color   color.NRGBA
19872                         Palette Texture
19873
19874                         Waving       WaveType
19875                         ConnectSides uint8
19876                         ConnectTo    []Content
19877                         InsideTint   color.NRGBA
19878                         Level        uint8 // Must be < 128.
19879
19880                         Translucent bool // Sunlight is scattered and becomes normal light.
19881                         Transparent bool // Sunlight isn't scattered.
19882                         LightSrc    uint8
19883
19884                         GndContent   bool
19885                         Collides     bool
19886                         Pointable    bool
19887                         Diggable     bool
19888                         Climbable    bool
19889                         Replaceable  bool
19890                         OnRightClick bool
19891
19892                         DmgPerSec int32
19893
19894                         LiquidType   LiquidType
19895                         FlowingAlt   string
19896                         SrcAlt       string
19897                         Viscosity    uint8 // 0-7
19898                         LiqRenewable bool
19899                         FlowRange    uint8
19900                         DrownDmg     uint8
19901                         Floodable    bool
19902
19903                         DrawBox, ColBox, SelBox NodeBox
19904
19905                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19906
19907                         LegacyFaceDir bool
19908                         LegacyMounted bool
19909
19910                         DigPredict string
19911
19912                         MaxLvl uint8
19913
19914                         AlphaUse
19915                 }))(obj)).ConnectTo) = make([]Content, local261)
19916                 for local262 := range (*(*(struct {
19917                         Param0 Content
19918
19919                         Name   string
19920                         Groups []Group
19921
19922                         P1Type   Param1Type
19923                         P2Type   Param2Type
19924                         DrawType DrawType
19925
19926                         Mesh  string
19927                         Scale float32
19928                         //mt:const uint8(6)
19929                         Tiles        [6]TileDef
19930                         OverlayTiles [6]TileDef
19931                         //mt:const uint8(6)
19932                         SpecialTiles [6]TileDef
19933
19934                         Color   color.NRGBA
19935                         Palette Texture
19936
19937                         Waving       WaveType
19938                         ConnectSides uint8
19939                         ConnectTo    []Content
19940                         InsideTint   color.NRGBA
19941                         Level        uint8 // Must be < 128.
19942
19943                         Translucent bool // Sunlight is scattered and becomes normal light.
19944                         Transparent bool // Sunlight isn't scattered.
19945                         LightSrc    uint8
19946
19947                         GndContent   bool
19948                         Collides     bool
19949                         Pointable    bool
19950                         Diggable     bool
19951                         Climbable    bool
19952                         Replaceable  bool
19953                         OnRightClick bool
19954
19955                         DmgPerSec int32
19956
19957                         LiquidType   LiquidType
19958                         FlowingAlt   string
19959                         SrcAlt       string
19960                         Viscosity    uint8 // 0-7
19961                         LiqRenewable bool
19962                         FlowRange    uint8
19963                         DrownDmg     uint8
19964                         Floodable    bool
19965
19966                         DrawBox, ColBox, SelBox NodeBox
19967
19968                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19969
19970                         LegacyFaceDir bool
19971                         LegacyMounted bool
19972
19973                         DigPredict string
19974
19975                         MaxLvl uint8
19976
19977                         AlphaUse
19978                 }))(obj)).ConnectTo {
19979                         if err := pcall(func() {
19980                                 (((*(*(struct {
19981                                         Param0 Content
19982
19983                                         Name   string
19984                                         Groups []Group
19985
19986                                         P1Type   Param1Type
19987                                         P2Type   Param2Type
19988                                         DrawType DrawType
19989
19990                                         Mesh  string
19991                                         Scale float32
19992                                         //mt:const uint8(6)
19993                                         Tiles        [6]TileDef
19994                                         OverlayTiles [6]TileDef
19995                                         //mt:const uint8(6)
19996                                         SpecialTiles [6]TileDef
19997
19998                                         Color   color.NRGBA
19999                                         Palette Texture
20000
20001                                         Waving       WaveType
20002                                         ConnectSides uint8
20003                                         ConnectTo    []Content
20004                                         InsideTint   color.NRGBA
20005                                         Level        uint8 // Must be < 128.
20006
20007                                         Translucent bool // Sunlight is scattered and becomes normal light.
20008                                         Transparent bool // Sunlight isn't scattered.
20009                                         LightSrc    uint8
20010
20011                                         GndContent   bool
20012                                         Collides     bool
20013                                         Pointable    bool
20014                                         Diggable     bool
20015                                         Climbable    bool
20016                                         Replaceable  bool
20017                                         OnRightClick bool
20018
20019                                         DmgPerSec int32
20020
20021                                         LiquidType   LiquidType
20022                                         FlowingAlt   string
20023                                         SrcAlt       string
20024                                         Viscosity    uint8 // 0-7
20025                                         LiqRenewable bool
20026                                         FlowRange    uint8
20027                                         DrownDmg     uint8
20028                                         Floodable    bool
20029
20030                                         DrawBox, ColBox, SelBox NodeBox
20031
20032                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20033
20034                                         LegacyFaceDir bool
20035                                         LegacyMounted bool
20036
20037                                         DigPredict string
20038
20039                                         MaxLvl uint8
20040
20041                                         AlphaUse
20042                                 }))(obj)).ConnectTo)[local262]).deserialize(r)
20043                         }); err != nil {
20044                                 if err == io.EOF {
20045                                         chk(io.EOF)
20046                                 }
20047                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
20048                         }
20049                 }
20050                 {
20051                         p := &(*(*(struct {
20052                                 Param0 Content
20053
20054                                 Name   string
20055                                 Groups []Group
20056
20057                                 P1Type   Param1Type
20058                                 P2Type   Param2Type
20059                                 DrawType DrawType
20060
20061                                 Mesh  string
20062                                 Scale float32
20063                                 //mt:const uint8(6)
20064                                 Tiles        [6]TileDef
20065                                 OverlayTiles [6]TileDef
20066                                 //mt:const uint8(6)
20067                                 SpecialTiles [6]TileDef
20068
20069                                 Color   color.NRGBA
20070                                 Palette Texture
20071
20072                                 Waving       WaveType
20073                                 ConnectSides uint8
20074                                 ConnectTo    []Content
20075                                 InsideTint   color.NRGBA
20076                                 Level        uint8 // Must be < 128.
20077
20078                                 Translucent bool // Sunlight is scattered and becomes normal light.
20079                                 Transparent bool // Sunlight isn't scattered.
20080                                 LightSrc    uint8
20081
20082                                 GndContent   bool
20083                                 Collides     bool
20084                                 Pointable    bool
20085                                 Diggable     bool
20086                                 Climbable    bool
20087                                 Replaceable  bool
20088                                 OnRightClick bool
20089
20090                                 DmgPerSec int32
20091
20092                                 LiquidType   LiquidType
20093                                 FlowingAlt   string
20094                                 SrcAlt       string
20095                                 Viscosity    uint8 // 0-7
20096                                 LiqRenewable bool
20097                                 FlowRange    uint8
20098                                 DrownDmg     uint8
20099                                 Floodable    bool
20100
20101                                 DrawBox, ColBox, SelBox NodeBox
20102
20103                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20104
20105                                 LegacyFaceDir bool
20106                                 LegacyMounted bool
20107
20108                                 DigPredict string
20109
20110                                 MaxLvl uint8
20111
20112                                 AlphaUse
20113                         }))(obj)).InsideTint
20114                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20115
20116                 }
20117                 {
20118                         p := &(*(*(struct {
20119                                 Param0 Content
20120
20121                                 Name   string
20122                                 Groups []Group
20123
20124                                 P1Type   Param1Type
20125                                 P2Type   Param2Type
20126                                 DrawType DrawType
20127
20128                                 Mesh  string
20129                                 Scale float32
20130                                 //mt:const uint8(6)
20131                                 Tiles        [6]TileDef
20132                                 OverlayTiles [6]TileDef
20133                                 //mt:const uint8(6)
20134                                 SpecialTiles [6]TileDef
20135
20136                                 Color   color.NRGBA
20137                                 Palette Texture
20138
20139                                 Waving       WaveType
20140                                 ConnectSides uint8
20141                                 ConnectTo    []Content
20142                                 InsideTint   color.NRGBA
20143                                 Level        uint8 // Must be < 128.
20144
20145                                 Translucent bool // Sunlight is scattered and becomes normal light.
20146                                 Transparent bool // Sunlight isn't scattered.
20147                                 LightSrc    uint8
20148
20149                                 GndContent   bool
20150                                 Collides     bool
20151                                 Pointable    bool
20152                                 Diggable     bool
20153                                 Climbable    bool
20154                                 Replaceable  bool
20155                                 OnRightClick bool
20156
20157                                 DmgPerSec int32
20158
20159                                 LiquidType   LiquidType
20160                                 FlowingAlt   string
20161                                 SrcAlt       string
20162                                 Viscosity    uint8 // 0-7
20163                                 LiqRenewable bool
20164                                 FlowRange    uint8
20165                                 DrownDmg     uint8
20166                                 Floodable    bool
20167
20168                                 DrawBox, ColBox, SelBox NodeBox
20169
20170                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20171
20172                                 LegacyFaceDir bool
20173                                 LegacyMounted bool
20174
20175                                 DigPredict string
20176
20177                                 MaxLvl uint8
20178
20179                                 AlphaUse
20180                         }))(obj)).Level
20181                         *p = read8(r)
20182                 }
20183                 {
20184                         p := &(*(*(struct {
20185                                 Param0 Content
20186
20187                                 Name   string
20188                                 Groups []Group
20189
20190                                 P1Type   Param1Type
20191                                 P2Type   Param2Type
20192                                 DrawType DrawType
20193
20194                                 Mesh  string
20195                                 Scale float32
20196                                 //mt:const uint8(6)
20197                                 Tiles        [6]TileDef
20198                                 OverlayTiles [6]TileDef
20199                                 //mt:const uint8(6)
20200                                 SpecialTiles [6]TileDef
20201
20202                                 Color   color.NRGBA
20203                                 Palette Texture
20204
20205                                 Waving       WaveType
20206                                 ConnectSides uint8
20207                                 ConnectTo    []Content
20208                                 InsideTint   color.NRGBA
20209                                 Level        uint8 // Must be < 128.
20210
20211                                 Translucent bool // Sunlight is scattered and becomes normal light.
20212                                 Transparent bool // Sunlight isn't scattered.
20213                                 LightSrc    uint8
20214
20215                                 GndContent   bool
20216                                 Collides     bool
20217                                 Pointable    bool
20218                                 Diggable     bool
20219                                 Climbable    bool
20220                                 Replaceable  bool
20221                                 OnRightClick bool
20222
20223                                 DmgPerSec int32
20224
20225                                 LiquidType   LiquidType
20226                                 FlowingAlt   string
20227                                 SrcAlt       string
20228                                 Viscosity    uint8 // 0-7
20229                                 LiqRenewable bool
20230                                 FlowRange    uint8
20231                                 DrownDmg     uint8
20232                                 Floodable    bool
20233
20234                                 DrawBox, ColBox, SelBox NodeBox
20235
20236                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20237
20238                                 LegacyFaceDir bool
20239                                 LegacyMounted bool
20240
20241                                 DigPredict string
20242
20243                                 MaxLvl uint8
20244
20245                                 AlphaUse
20246                         }))(obj)).Translucent
20247                         switch n := read8(r); n {
20248                         case 0:
20249                                 *p = false
20250                         case 1:
20251                                 *p = true
20252                         default:
20253                                 chk(fmt.Errorf("invalid bool: %d", n))
20254                         }
20255
20256                 }
20257                 {
20258                         p := &(*(*(struct {
20259                                 Param0 Content
20260
20261                                 Name   string
20262                                 Groups []Group
20263
20264                                 P1Type   Param1Type
20265                                 P2Type   Param2Type
20266                                 DrawType DrawType
20267
20268                                 Mesh  string
20269                                 Scale float32
20270                                 //mt:const uint8(6)
20271                                 Tiles        [6]TileDef
20272                                 OverlayTiles [6]TileDef
20273                                 //mt:const uint8(6)
20274                                 SpecialTiles [6]TileDef
20275
20276                                 Color   color.NRGBA
20277                                 Palette Texture
20278
20279                                 Waving       WaveType
20280                                 ConnectSides uint8
20281                                 ConnectTo    []Content
20282                                 InsideTint   color.NRGBA
20283                                 Level        uint8 // Must be < 128.
20284
20285                                 Translucent bool // Sunlight is scattered and becomes normal light.
20286                                 Transparent bool // Sunlight isn't scattered.
20287                                 LightSrc    uint8
20288
20289                                 GndContent   bool
20290                                 Collides     bool
20291                                 Pointable    bool
20292                                 Diggable     bool
20293                                 Climbable    bool
20294                                 Replaceable  bool
20295                                 OnRightClick bool
20296
20297                                 DmgPerSec int32
20298
20299                                 LiquidType   LiquidType
20300                                 FlowingAlt   string
20301                                 SrcAlt       string
20302                                 Viscosity    uint8 // 0-7
20303                                 LiqRenewable bool
20304                                 FlowRange    uint8
20305                                 DrownDmg     uint8
20306                                 Floodable    bool
20307
20308                                 DrawBox, ColBox, SelBox NodeBox
20309
20310                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20311
20312                                 LegacyFaceDir bool
20313                                 LegacyMounted bool
20314
20315                                 DigPredict string
20316
20317                                 MaxLvl uint8
20318
20319                                 AlphaUse
20320                         }))(obj)).Transparent
20321                         switch n := read8(r); n {
20322                         case 0:
20323                                 *p = false
20324                         case 1:
20325                                 *p = true
20326                         default:
20327                                 chk(fmt.Errorf("invalid bool: %d", n))
20328                         }
20329
20330                 }
20331                 {
20332                         p := &(*(*(struct {
20333                                 Param0 Content
20334
20335                                 Name   string
20336                                 Groups []Group
20337
20338                                 P1Type   Param1Type
20339                                 P2Type   Param2Type
20340                                 DrawType DrawType
20341
20342                                 Mesh  string
20343                                 Scale float32
20344                                 //mt:const uint8(6)
20345                                 Tiles        [6]TileDef
20346                                 OverlayTiles [6]TileDef
20347                                 //mt:const uint8(6)
20348                                 SpecialTiles [6]TileDef
20349
20350                                 Color   color.NRGBA
20351                                 Palette Texture
20352
20353                                 Waving       WaveType
20354                                 ConnectSides uint8
20355                                 ConnectTo    []Content
20356                                 InsideTint   color.NRGBA
20357                                 Level        uint8 // Must be < 128.
20358
20359                                 Translucent bool // Sunlight is scattered and becomes normal light.
20360                                 Transparent bool // Sunlight isn't scattered.
20361                                 LightSrc    uint8
20362
20363                                 GndContent   bool
20364                                 Collides     bool
20365                                 Pointable    bool
20366                                 Diggable     bool
20367                                 Climbable    bool
20368                                 Replaceable  bool
20369                                 OnRightClick bool
20370
20371                                 DmgPerSec int32
20372
20373                                 LiquidType   LiquidType
20374                                 FlowingAlt   string
20375                                 SrcAlt       string
20376                                 Viscosity    uint8 // 0-7
20377                                 LiqRenewable bool
20378                                 FlowRange    uint8
20379                                 DrownDmg     uint8
20380                                 Floodable    bool
20381
20382                                 DrawBox, ColBox, SelBox NodeBox
20383
20384                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20385
20386                                 LegacyFaceDir bool
20387                                 LegacyMounted bool
20388
20389                                 DigPredict string
20390
20391                                 MaxLvl uint8
20392
20393                                 AlphaUse
20394                         }))(obj)).LightSrc
20395                         *p = read8(r)
20396                 }
20397                 {
20398                         p := &(*(*(struct {
20399                                 Param0 Content
20400
20401                                 Name   string
20402                                 Groups []Group
20403
20404                                 P1Type   Param1Type
20405                                 P2Type   Param2Type
20406                                 DrawType DrawType
20407
20408                                 Mesh  string
20409                                 Scale float32
20410                                 //mt:const uint8(6)
20411                                 Tiles        [6]TileDef
20412                                 OverlayTiles [6]TileDef
20413                                 //mt:const uint8(6)
20414                                 SpecialTiles [6]TileDef
20415
20416                                 Color   color.NRGBA
20417                                 Palette Texture
20418
20419                                 Waving       WaveType
20420                                 ConnectSides uint8
20421                                 ConnectTo    []Content
20422                                 InsideTint   color.NRGBA
20423                                 Level        uint8 // Must be < 128.
20424
20425                                 Translucent bool // Sunlight is scattered and becomes normal light.
20426                                 Transparent bool // Sunlight isn't scattered.
20427                                 LightSrc    uint8
20428
20429                                 GndContent   bool
20430                                 Collides     bool
20431                                 Pointable    bool
20432                                 Diggable     bool
20433                                 Climbable    bool
20434                                 Replaceable  bool
20435                                 OnRightClick bool
20436
20437                                 DmgPerSec int32
20438
20439                                 LiquidType   LiquidType
20440                                 FlowingAlt   string
20441                                 SrcAlt       string
20442                                 Viscosity    uint8 // 0-7
20443                                 LiqRenewable bool
20444                                 FlowRange    uint8
20445                                 DrownDmg     uint8
20446                                 Floodable    bool
20447
20448                                 DrawBox, ColBox, SelBox NodeBox
20449
20450                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20451
20452                                 LegacyFaceDir bool
20453                                 LegacyMounted bool
20454
20455                                 DigPredict string
20456
20457                                 MaxLvl uint8
20458
20459                                 AlphaUse
20460                         }))(obj)).GndContent
20461                         switch n := read8(r); n {
20462                         case 0:
20463                                 *p = false
20464                         case 1:
20465                                 *p = true
20466                         default:
20467                                 chk(fmt.Errorf("invalid bool: %d", n))
20468                         }
20469
20470                 }
20471                 {
20472                         p := &(*(*(struct {
20473                                 Param0 Content
20474
20475                                 Name   string
20476                                 Groups []Group
20477
20478                                 P1Type   Param1Type
20479                                 P2Type   Param2Type
20480                                 DrawType DrawType
20481
20482                                 Mesh  string
20483                                 Scale float32
20484                                 //mt:const uint8(6)
20485                                 Tiles        [6]TileDef
20486                                 OverlayTiles [6]TileDef
20487                                 //mt:const uint8(6)
20488                                 SpecialTiles [6]TileDef
20489
20490                                 Color   color.NRGBA
20491                                 Palette Texture
20492
20493                                 Waving       WaveType
20494                                 ConnectSides uint8
20495                                 ConnectTo    []Content
20496                                 InsideTint   color.NRGBA
20497                                 Level        uint8 // Must be < 128.
20498
20499                                 Translucent bool // Sunlight is scattered and becomes normal light.
20500                                 Transparent bool // Sunlight isn't scattered.
20501                                 LightSrc    uint8
20502
20503                                 GndContent   bool
20504                                 Collides     bool
20505                                 Pointable    bool
20506                                 Diggable     bool
20507                                 Climbable    bool
20508                                 Replaceable  bool
20509                                 OnRightClick bool
20510
20511                                 DmgPerSec int32
20512
20513                                 LiquidType   LiquidType
20514                                 FlowingAlt   string
20515                                 SrcAlt       string
20516                                 Viscosity    uint8 // 0-7
20517                                 LiqRenewable bool
20518                                 FlowRange    uint8
20519                                 DrownDmg     uint8
20520                                 Floodable    bool
20521
20522                                 DrawBox, ColBox, SelBox NodeBox
20523
20524                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20525
20526                                 LegacyFaceDir bool
20527                                 LegacyMounted bool
20528
20529                                 DigPredict string
20530
20531                                 MaxLvl uint8
20532
20533                                 AlphaUse
20534                         }))(obj)).Collides
20535                         switch n := read8(r); n {
20536                         case 0:
20537                                 *p = false
20538                         case 1:
20539                                 *p = true
20540                         default:
20541                                 chk(fmt.Errorf("invalid bool: %d", n))
20542                         }
20543
20544                 }
20545                 {
20546                         p := &(*(*(struct {
20547                                 Param0 Content
20548
20549                                 Name   string
20550                                 Groups []Group
20551
20552                                 P1Type   Param1Type
20553                                 P2Type   Param2Type
20554                                 DrawType DrawType
20555
20556                                 Mesh  string
20557                                 Scale float32
20558                                 //mt:const uint8(6)
20559                                 Tiles        [6]TileDef
20560                                 OverlayTiles [6]TileDef
20561                                 //mt:const uint8(6)
20562                                 SpecialTiles [6]TileDef
20563
20564                                 Color   color.NRGBA
20565                                 Palette Texture
20566
20567                                 Waving       WaveType
20568                                 ConnectSides uint8
20569                                 ConnectTo    []Content
20570                                 InsideTint   color.NRGBA
20571                                 Level        uint8 // Must be < 128.
20572
20573                                 Translucent bool // Sunlight is scattered and becomes normal light.
20574                                 Transparent bool // Sunlight isn't scattered.
20575                                 LightSrc    uint8
20576
20577                                 GndContent   bool
20578                                 Collides     bool
20579                                 Pointable    bool
20580                                 Diggable     bool
20581                                 Climbable    bool
20582                                 Replaceable  bool
20583                                 OnRightClick bool
20584
20585                                 DmgPerSec int32
20586
20587                                 LiquidType   LiquidType
20588                                 FlowingAlt   string
20589                                 SrcAlt       string
20590                                 Viscosity    uint8 // 0-7
20591                                 LiqRenewable bool
20592                                 FlowRange    uint8
20593                                 DrownDmg     uint8
20594                                 Floodable    bool
20595
20596                                 DrawBox, ColBox, SelBox NodeBox
20597
20598                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20599
20600                                 LegacyFaceDir bool
20601                                 LegacyMounted bool
20602
20603                                 DigPredict string
20604
20605                                 MaxLvl uint8
20606
20607                                 AlphaUse
20608                         }))(obj)).Pointable
20609                         switch n := read8(r); n {
20610                         case 0:
20611                                 *p = false
20612                         case 1:
20613                                 *p = true
20614                         default:
20615                                 chk(fmt.Errorf("invalid bool: %d", n))
20616                         }
20617
20618                 }
20619                 {
20620                         p := &(*(*(struct {
20621                                 Param0 Content
20622
20623                                 Name   string
20624                                 Groups []Group
20625
20626                                 P1Type   Param1Type
20627                                 P2Type   Param2Type
20628                                 DrawType DrawType
20629
20630                                 Mesh  string
20631                                 Scale float32
20632                                 //mt:const uint8(6)
20633                                 Tiles        [6]TileDef
20634                                 OverlayTiles [6]TileDef
20635                                 //mt:const uint8(6)
20636                                 SpecialTiles [6]TileDef
20637
20638                                 Color   color.NRGBA
20639                                 Palette Texture
20640
20641                                 Waving       WaveType
20642                                 ConnectSides uint8
20643                                 ConnectTo    []Content
20644                                 InsideTint   color.NRGBA
20645                                 Level        uint8 // Must be < 128.
20646
20647                                 Translucent bool // Sunlight is scattered and becomes normal light.
20648                                 Transparent bool // Sunlight isn't scattered.
20649                                 LightSrc    uint8
20650
20651                                 GndContent   bool
20652                                 Collides     bool
20653                                 Pointable    bool
20654                                 Diggable     bool
20655                                 Climbable    bool
20656                                 Replaceable  bool
20657                                 OnRightClick bool
20658
20659                                 DmgPerSec int32
20660
20661                                 LiquidType   LiquidType
20662                                 FlowingAlt   string
20663                                 SrcAlt       string
20664                                 Viscosity    uint8 // 0-7
20665                                 LiqRenewable bool
20666                                 FlowRange    uint8
20667                                 DrownDmg     uint8
20668                                 Floodable    bool
20669
20670                                 DrawBox, ColBox, SelBox NodeBox
20671
20672                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20673
20674                                 LegacyFaceDir bool
20675                                 LegacyMounted bool
20676
20677                                 DigPredict string
20678
20679                                 MaxLvl uint8
20680
20681                                 AlphaUse
20682                         }))(obj)).Diggable
20683                         switch n := read8(r); n {
20684                         case 0:
20685                                 *p = false
20686                         case 1:
20687                                 *p = true
20688                         default:
20689                                 chk(fmt.Errorf("invalid bool: %d", n))
20690                         }
20691
20692                 }
20693                 {
20694                         p := &(*(*(struct {
20695                                 Param0 Content
20696
20697                                 Name   string
20698                                 Groups []Group
20699
20700                                 P1Type   Param1Type
20701                                 P2Type   Param2Type
20702                                 DrawType DrawType
20703
20704                                 Mesh  string
20705                                 Scale float32
20706                                 //mt:const uint8(6)
20707                                 Tiles        [6]TileDef
20708                                 OverlayTiles [6]TileDef
20709                                 //mt:const uint8(6)
20710                                 SpecialTiles [6]TileDef
20711
20712                                 Color   color.NRGBA
20713                                 Palette Texture
20714
20715                                 Waving       WaveType
20716                                 ConnectSides uint8
20717                                 ConnectTo    []Content
20718                                 InsideTint   color.NRGBA
20719                                 Level        uint8 // Must be < 128.
20720
20721                                 Translucent bool // Sunlight is scattered and becomes normal light.
20722                                 Transparent bool // Sunlight isn't scattered.
20723                                 LightSrc    uint8
20724
20725                                 GndContent   bool
20726                                 Collides     bool
20727                                 Pointable    bool
20728                                 Diggable     bool
20729                                 Climbable    bool
20730                                 Replaceable  bool
20731                                 OnRightClick bool
20732
20733                                 DmgPerSec int32
20734
20735                                 LiquidType   LiquidType
20736                                 FlowingAlt   string
20737                                 SrcAlt       string
20738                                 Viscosity    uint8 // 0-7
20739                                 LiqRenewable bool
20740                                 FlowRange    uint8
20741                                 DrownDmg     uint8
20742                                 Floodable    bool
20743
20744                                 DrawBox, ColBox, SelBox NodeBox
20745
20746                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20747
20748                                 LegacyFaceDir bool
20749                                 LegacyMounted bool
20750
20751                                 DigPredict string
20752
20753                                 MaxLvl uint8
20754
20755                                 AlphaUse
20756                         }))(obj)).Climbable
20757                         switch n := read8(r); n {
20758                         case 0:
20759                                 *p = false
20760                         case 1:
20761                                 *p = true
20762                         default:
20763                                 chk(fmt.Errorf("invalid bool: %d", n))
20764                         }
20765
20766                 }
20767                 {
20768                         p := &(*(*(struct {
20769                                 Param0 Content
20770
20771                                 Name   string
20772                                 Groups []Group
20773
20774                                 P1Type   Param1Type
20775                                 P2Type   Param2Type
20776                                 DrawType DrawType
20777
20778                                 Mesh  string
20779                                 Scale float32
20780                                 //mt:const uint8(6)
20781                                 Tiles        [6]TileDef
20782                                 OverlayTiles [6]TileDef
20783                                 //mt:const uint8(6)
20784                                 SpecialTiles [6]TileDef
20785
20786                                 Color   color.NRGBA
20787                                 Palette Texture
20788
20789                                 Waving       WaveType
20790                                 ConnectSides uint8
20791                                 ConnectTo    []Content
20792                                 InsideTint   color.NRGBA
20793                                 Level        uint8 // Must be < 128.
20794
20795                                 Translucent bool // Sunlight is scattered and becomes normal light.
20796                                 Transparent bool // Sunlight isn't scattered.
20797                                 LightSrc    uint8
20798
20799                                 GndContent   bool
20800                                 Collides     bool
20801                                 Pointable    bool
20802                                 Diggable     bool
20803                                 Climbable    bool
20804                                 Replaceable  bool
20805                                 OnRightClick bool
20806
20807                                 DmgPerSec int32
20808
20809                                 LiquidType   LiquidType
20810                                 FlowingAlt   string
20811                                 SrcAlt       string
20812                                 Viscosity    uint8 // 0-7
20813                                 LiqRenewable bool
20814                                 FlowRange    uint8
20815                                 DrownDmg     uint8
20816                                 Floodable    bool
20817
20818                                 DrawBox, ColBox, SelBox NodeBox
20819
20820                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20821
20822                                 LegacyFaceDir bool
20823                                 LegacyMounted bool
20824
20825                                 DigPredict string
20826
20827                                 MaxLvl uint8
20828
20829                                 AlphaUse
20830                         }))(obj)).Replaceable
20831                         switch n := read8(r); n {
20832                         case 0:
20833                                 *p = false
20834                         case 1:
20835                                 *p = true
20836                         default:
20837                                 chk(fmt.Errorf("invalid bool: %d", n))
20838                         }
20839
20840                 }
20841                 {
20842                         p := &(*(*(struct {
20843                                 Param0 Content
20844
20845                                 Name   string
20846                                 Groups []Group
20847
20848                                 P1Type   Param1Type
20849                                 P2Type   Param2Type
20850                                 DrawType DrawType
20851
20852                                 Mesh  string
20853                                 Scale float32
20854                                 //mt:const uint8(6)
20855                                 Tiles        [6]TileDef
20856                                 OverlayTiles [6]TileDef
20857                                 //mt:const uint8(6)
20858                                 SpecialTiles [6]TileDef
20859
20860                                 Color   color.NRGBA
20861                                 Palette Texture
20862
20863                                 Waving       WaveType
20864                                 ConnectSides uint8
20865                                 ConnectTo    []Content
20866                                 InsideTint   color.NRGBA
20867                                 Level        uint8 // Must be < 128.
20868
20869                                 Translucent bool // Sunlight is scattered and becomes normal light.
20870                                 Transparent bool // Sunlight isn't scattered.
20871                                 LightSrc    uint8
20872
20873                                 GndContent   bool
20874                                 Collides     bool
20875                                 Pointable    bool
20876                                 Diggable     bool
20877                                 Climbable    bool
20878                                 Replaceable  bool
20879                                 OnRightClick bool
20880
20881                                 DmgPerSec int32
20882
20883                                 LiquidType   LiquidType
20884                                 FlowingAlt   string
20885                                 SrcAlt       string
20886                                 Viscosity    uint8 // 0-7
20887                                 LiqRenewable bool
20888                                 FlowRange    uint8
20889                                 DrownDmg     uint8
20890                                 Floodable    bool
20891
20892                                 DrawBox, ColBox, SelBox NodeBox
20893
20894                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20895
20896                                 LegacyFaceDir bool
20897                                 LegacyMounted bool
20898
20899                                 DigPredict string
20900
20901                                 MaxLvl uint8
20902
20903                                 AlphaUse
20904                         }))(obj)).OnRightClick
20905                         switch n := read8(r); n {
20906                         case 0:
20907                                 *p = false
20908                         case 1:
20909                                 *p = true
20910                         default:
20911                                 chk(fmt.Errorf("invalid bool: %d", n))
20912                         }
20913
20914                 }
20915                 {
20916                         p := &(*(*(struct {
20917                                 Param0 Content
20918
20919                                 Name   string
20920                                 Groups []Group
20921
20922                                 P1Type   Param1Type
20923                                 P2Type   Param2Type
20924                                 DrawType DrawType
20925
20926                                 Mesh  string
20927                                 Scale float32
20928                                 //mt:const uint8(6)
20929                                 Tiles        [6]TileDef
20930                                 OverlayTiles [6]TileDef
20931                                 //mt:const uint8(6)
20932                                 SpecialTiles [6]TileDef
20933
20934                                 Color   color.NRGBA
20935                                 Palette Texture
20936
20937                                 Waving       WaveType
20938                                 ConnectSides uint8
20939                                 ConnectTo    []Content
20940                                 InsideTint   color.NRGBA
20941                                 Level        uint8 // Must be < 128.
20942
20943                                 Translucent bool // Sunlight is scattered and becomes normal light.
20944                                 Transparent bool // Sunlight isn't scattered.
20945                                 LightSrc    uint8
20946
20947                                 GndContent   bool
20948                                 Collides     bool
20949                                 Pointable    bool
20950                                 Diggable     bool
20951                                 Climbable    bool
20952                                 Replaceable  bool
20953                                 OnRightClick bool
20954
20955                                 DmgPerSec int32
20956
20957                                 LiquidType   LiquidType
20958                                 FlowingAlt   string
20959                                 SrcAlt       string
20960                                 Viscosity    uint8 // 0-7
20961                                 LiqRenewable bool
20962                                 FlowRange    uint8
20963                                 DrownDmg     uint8
20964                                 Floodable    bool
20965
20966                                 DrawBox, ColBox, SelBox NodeBox
20967
20968                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20969
20970                                 LegacyFaceDir bool
20971                                 LegacyMounted bool
20972
20973                                 DigPredict string
20974
20975                                 MaxLvl uint8
20976
20977                                 AlphaUse
20978                         }))(obj)).DmgPerSec
20979                         *p = int32(read32(r))
20980                 }
20981                 if err := pcall(func() {
20982                         ((*(*(struct {
20983                                 Param0 Content
20984
20985                                 Name   string
20986                                 Groups []Group
20987
20988                                 P1Type   Param1Type
20989                                 P2Type   Param2Type
20990                                 DrawType DrawType
20991
20992                                 Mesh  string
20993                                 Scale float32
20994                                 //mt:const uint8(6)
20995                                 Tiles        [6]TileDef
20996                                 OverlayTiles [6]TileDef
20997                                 //mt:const uint8(6)
20998                                 SpecialTiles [6]TileDef
20999
21000                                 Color   color.NRGBA
21001                                 Palette Texture
21002
21003                                 Waving       WaveType
21004                                 ConnectSides uint8
21005                                 ConnectTo    []Content
21006                                 InsideTint   color.NRGBA
21007                                 Level        uint8 // Must be < 128.
21008
21009                                 Translucent bool // Sunlight is scattered and becomes normal light.
21010                                 Transparent bool // Sunlight isn't scattered.
21011                                 LightSrc    uint8
21012
21013                                 GndContent   bool
21014                                 Collides     bool
21015                                 Pointable    bool
21016                                 Diggable     bool
21017                                 Climbable    bool
21018                                 Replaceable  bool
21019                                 OnRightClick bool
21020
21021                                 DmgPerSec int32
21022
21023                                 LiquidType   LiquidType
21024                                 FlowingAlt   string
21025                                 SrcAlt       string
21026                                 Viscosity    uint8 // 0-7
21027                                 LiqRenewable bool
21028                                 FlowRange    uint8
21029                                 DrownDmg     uint8
21030                                 Floodable    bool
21031
21032                                 DrawBox, ColBox, SelBox NodeBox
21033
21034                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21035
21036                                 LegacyFaceDir bool
21037                                 LegacyMounted bool
21038
21039                                 DigPredict string
21040
21041                                 MaxLvl uint8
21042
21043                                 AlphaUse
21044                         }))(obj)).LiquidType).deserialize(r)
21045                 }); err != nil {
21046                         if err == io.EOF {
21047                                 chk(io.EOF)
21048                         }
21049                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LiquidType", err))
21050                 }
21051                 var local263 []uint8
21052                 var local264 uint16
21053                 {
21054                         p := &local264
21055                         *p = read16(r)
21056                 }
21057                 (local263) = make([]uint8, local264)
21058                 {
21059                         _, err := io.ReadFull(r, (local263)[:])
21060                         chk(err)
21061                 }
21062                 ((*(*(struct {
21063                         Param0 Content
21064
21065                         Name   string
21066                         Groups []Group
21067
21068                         P1Type   Param1Type
21069                         P2Type   Param2Type
21070                         DrawType DrawType
21071
21072                         Mesh  string
21073                         Scale float32
21074                         //mt:const uint8(6)
21075                         Tiles        [6]TileDef
21076                         OverlayTiles [6]TileDef
21077                         //mt:const uint8(6)
21078                         SpecialTiles [6]TileDef
21079
21080                         Color   color.NRGBA
21081                         Palette Texture
21082
21083                         Waving       WaveType
21084                         ConnectSides uint8
21085                         ConnectTo    []Content
21086                         InsideTint   color.NRGBA
21087                         Level        uint8 // Must be < 128.
21088
21089                         Translucent bool // Sunlight is scattered and becomes normal light.
21090                         Transparent bool // Sunlight isn't scattered.
21091                         LightSrc    uint8
21092
21093                         GndContent   bool
21094                         Collides     bool
21095                         Pointable    bool
21096                         Diggable     bool
21097                         Climbable    bool
21098                         Replaceable  bool
21099                         OnRightClick bool
21100
21101                         DmgPerSec int32
21102
21103                         LiquidType   LiquidType
21104                         FlowingAlt   string
21105                         SrcAlt       string
21106                         Viscosity    uint8 // 0-7
21107                         LiqRenewable bool
21108                         FlowRange    uint8
21109                         DrownDmg     uint8
21110                         Floodable    bool
21111
21112                         DrawBox, ColBox, SelBox NodeBox
21113
21114                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21115
21116                         LegacyFaceDir bool
21117                         LegacyMounted bool
21118
21119                         DigPredict string
21120
21121                         MaxLvl uint8
21122
21123                         AlphaUse
21124                 }))(obj)).FlowingAlt) = string(local263)
21125                 var local265 []uint8
21126                 var local266 uint16
21127                 {
21128                         p := &local266
21129                         *p = read16(r)
21130                 }
21131                 (local265) = make([]uint8, local266)
21132                 {
21133                         _, err := io.ReadFull(r, (local265)[:])
21134                         chk(err)
21135                 }
21136                 ((*(*(struct {
21137                         Param0 Content
21138
21139                         Name   string
21140                         Groups []Group
21141
21142                         P1Type   Param1Type
21143                         P2Type   Param2Type
21144                         DrawType DrawType
21145
21146                         Mesh  string
21147                         Scale float32
21148                         //mt:const uint8(6)
21149                         Tiles        [6]TileDef
21150                         OverlayTiles [6]TileDef
21151                         //mt:const uint8(6)
21152                         SpecialTiles [6]TileDef
21153
21154                         Color   color.NRGBA
21155                         Palette Texture
21156
21157                         Waving       WaveType
21158                         ConnectSides uint8
21159                         ConnectTo    []Content
21160                         InsideTint   color.NRGBA
21161                         Level        uint8 // Must be < 128.
21162
21163                         Translucent bool // Sunlight is scattered and becomes normal light.
21164                         Transparent bool // Sunlight isn't scattered.
21165                         LightSrc    uint8
21166
21167                         GndContent   bool
21168                         Collides     bool
21169                         Pointable    bool
21170                         Diggable     bool
21171                         Climbable    bool
21172                         Replaceable  bool
21173                         OnRightClick bool
21174
21175                         DmgPerSec int32
21176
21177                         LiquidType   LiquidType
21178                         FlowingAlt   string
21179                         SrcAlt       string
21180                         Viscosity    uint8 // 0-7
21181                         LiqRenewable bool
21182                         FlowRange    uint8
21183                         DrownDmg     uint8
21184                         Floodable    bool
21185
21186                         DrawBox, ColBox, SelBox NodeBox
21187
21188                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21189
21190                         LegacyFaceDir bool
21191                         LegacyMounted bool
21192
21193                         DigPredict string
21194
21195                         MaxLvl uint8
21196
21197                         AlphaUse
21198                 }))(obj)).SrcAlt) = string(local265)
21199                 {
21200                         p := &(*(*(struct {
21201                                 Param0 Content
21202
21203                                 Name   string
21204                                 Groups []Group
21205
21206                                 P1Type   Param1Type
21207                                 P2Type   Param2Type
21208                                 DrawType DrawType
21209
21210                                 Mesh  string
21211                                 Scale float32
21212                                 //mt:const uint8(6)
21213                                 Tiles        [6]TileDef
21214                                 OverlayTiles [6]TileDef
21215                                 //mt:const uint8(6)
21216                                 SpecialTiles [6]TileDef
21217
21218                                 Color   color.NRGBA
21219                                 Palette Texture
21220
21221                                 Waving       WaveType
21222                                 ConnectSides uint8
21223                                 ConnectTo    []Content
21224                                 InsideTint   color.NRGBA
21225                                 Level        uint8 // Must be < 128.
21226
21227                                 Translucent bool // Sunlight is scattered and becomes normal light.
21228                                 Transparent bool // Sunlight isn't scattered.
21229                                 LightSrc    uint8
21230
21231                                 GndContent   bool
21232                                 Collides     bool
21233                                 Pointable    bool
21234                                 Diggable     bool
21235                                 Climbable    bool
21236                                 Replaceable  bool
21237                                 OnRightClick bool
21238
21239                                 DmgPerSec int32
21240
21241                                 LiquidType   LiquidType
21242                                 FlowingAlt   string
21243                                 SrcAlt       string
21244                                 Viscosity    uint8 // 0-7
21245                                 LiqRenewable bool
21246                                 FlowRange    uint8
21247                                 DrownDmg     uint8
21248                                 Floodable    bool
21249
21250                                 DrawBox, ColBox, SelBox NodeBox
21251
21252                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21253
21254                                 LegacyFaceDir bool
21255                                 LegacyMounted bool
21256
21257                                 DigPredict string
21258
21259                                 MaxLvl uint8
21260
21261                                 AlphaUse
21262                         }))(obj)).Viscosity
21263                         *p = read8(r)
21264                 }
21265                 {
21266                         p := &(*(*(struct {
21267                                 Param0 Content
21268
21269                                 Name   string
21270                                 Groups []Group
21271
21272                                 P1Type   Param1Type
21273                                 P2Type   Param2Type
21274                                 DrawType DrawType
21275
21276                                 Mesh  string
21277                                 Scale float32
21278                                 //mt:const uint8(6)
21279                                 Tiles        [6]TileDef
21280                                 OverlayTiles [6]TileDef
21281                                 //mt:const uint8(6)
21282                                 SpecialTiles [6]TileDef
21283
21284                                 Color   color.NRGBA
21285                                 Palette Texture
21286
21287                                 Waving       WaveType
21288                                 ConnectSides uint8
21289                                 ConnectTo    []Content
21290                                 InsideTint   color.NRGBA
21291                                 Level        uint8 // Must be < 128.
21292
21293                                 Translucent bool // Sunlight is scattered and becomes normal light.
21294                                 Transparent bool // Sunlight isn't scattered.
21295                                 LightSrc    uint8
21296
21297                                 GndContent   bool
21298                                 Collides     bool
21299                                 Pointable    bool
21300                                 Diggable     bool
21301                                 Climbable    bool
21302                                 Replaceable  bool
21303                                 OnRightClick bool
21304
21305                                 DmgPerSec int32
21306
21307                                 LiquidType   LiquidType
21308                                 FlowingAlt   string
21309                                 SrcAlt       string
21310                                 Viscosity    uint8 // 0-7
21311                                 LiqRenewable bool
21312                                 FlowRange    uint8
21313                                 DrownDmg     uint8
21314                                 Floodable    bool
21315
21316                                 DrawBox, ColBox, SelBox NodeBox
21317
21318                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21319
21320                                 LegacyFaceDir bool
21321                                 LegacyMounted bool
21322
21323                                 DigPredict string
21324
21325                                 MaxLvl uint8
21326
21327                                 AlphaUse
21328                         }))(obj)).LiqRenewable
21329                         switch n := read8(r); n {
21330                         case 0:
21331                                 *p = false
21332                         case 1:
21333                                 *p = true
21334                         default:
21335                                 chk(fmt.Errorf("invalid bool: %d", n))
21336                         }
21337
21338                 }
21339                 {
21340                         p := &(*(*(struct {
21341                                 Param0 Content
21342
21343                                 Name   string
21344                                 Groups []Group
21345
21346                                 P1Type   Param1Type
21347                                 P2Type   Param2Type
21348                                 DrawType DrawType
21349
21350                                 Mesh  string
21351                                 Scale float32
21352                                 //mt:const uint8(6)
21353                                 Tiles        [6]TileDef
21354                                 OverlayTiles [6]TileDef
21355                                 //mt:const uint8(6)
21356                                 SpecialTiles [6]TileDef
21357
21358                                 Color   color.NRGBA
21359                                 Palette Texture
21360
21361                                 Waving       WaveType
21362                                 ConnectSides uint8
21363                                 ConnectTo    []Content
21364                                 InsideTint   color.NRGBA
21365                                 Level        uint8 // Must be < 128.
21366
21367                                 Translucent bool // Sunlight is scattered and becomes normal light.
21368                                 Transparent bool // Sunlight isn't scattered.
21369                                 LightSrc    uint8
21370
21371                                 GndContent   bool
21372                                 Collides     bool
21373                                 Pointable    bool
21374                                 Diggable     bool
21375                                 Climbable    bool
21376                                 Replaceable  bool
21377                                 OnRightClick bool
21378
21379                                 DmgPerSec int32
21380
21381                                 LiquidType   LiquidType
21382                                 FlowingAlt   string
21383                                 SrcAlt       string
21384                                 Viscosity    uint8 // 0-7
21385                                 LiqRenewable bool
21386                                 FlowRange    uint8
21387                                 DrownDmg     uint8
21388                                 Floodable    bool
21389
21390                                 DrawBox, ColBox, SelBox NodeBox
21391
21392                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21393
21394                                 LegacyFaceDir bool
21395                                 LegacyMounted bool
21396
21397                                 DigPredict string
21398
21399                                 MaxLvl uint8
21400
21401                                 AlphaUse
21402                         }))(obj)).FlowRange
21403                         *p = read8(r)
21404                 }
21405                 {
21406                         p := &(*(*(struct {
21407                                 Param0 Content
21408
21409                                 Name   string
21410                                 Groups []Group
21411
21412                                 P1Type   Param1Type
21413                                 P2Type   Param2Type
21414                                 DrawType DrawType
21415
21416                                 Mesh  string
21417                                 Scale float32
21418                                 //mt:const uint8(6)
21419                                 Tiles        [6]TileDef
21420                                 OverlayTiles [6]TileDef
21421                                 //mt:const uint8(6)
21422                                 SpecialTiles [6]TileDef
21423
21424                                 Color   color.NRGBA
21425                                 Palette Texture
21426
21427                                 Waving       WaveType
21428                                 ConnectSides uint8
21429                                 ConnectTo    []Content
21430                                 InsideTint   color.NRGBA
21431                                 Level        uint8 // Must be < 128.
21432
21433                                 Translucent bool // Sunlight is scattered and becomes normal light.
21434                                 Transparent bool // Sunlight isn't scattered.
21435                                 LightSrc    uint8
21436
21437                                 GndContent   bool
21438                                 Collides     bool
21439                                 Pointable    bool
21440                                 Diggable     bool
21441                                 Climbable    bool
21442                                 Replaceable  bool
21443                                 OnRightClick bool
21444
21445                                 DmgPerSec int32
21446
21447                                 LiquidType   LiquidType
21448                                 FlowingAlt   string
21449                                 SrcAlt       string
21450                                 Viscosity    uint8 // 0-7
21451                                 LiqRenewable bool
21452                                 FlowRange    uint8
21453                                 DrownDmg     uint8
21454                                 Floodable    bool
21455
21456                                 DrawBox, ColBox, SelBox NodeBox
21457
21458                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21459
21460                                 LegacyFaceDir bool
21461                                 LegacyMounted bool
21462
21463                                 DigPredict string
21464
21465                                 MaxLvl uint8
21466
21467                                 AlphaUse
21468                         }))(obj)).DrownDmg
21469                         *p = read8(r)
21470                 }
21471                 {
21472                         p := &(*(*(struct {
21473                                 Param0 Content
21474
21475                                 Name   string
21476                                 Groups []Group
21477
21478                                 P1Type   Param1Type
21479                                 P2Type   Param2Type
21480                                 DrawType DrawType
21481
21482                                 Mesh  string
21483                                 Scale float32
21484                                 //mt:const uint8(6)
21485                                 Tiles        [6]TileDef
21486                                 OverlayTiles [6]TileDef
21487                                 //mt:const uint8(6)
21488                                 SpecialTiles [6]TileDef
21489
21490                                 Color   color.NRGBA
21491                                 Palette Texture
21492
21493                                 Waving       WaveType
21494                                 ConnectSides uint8
21495                                 ConnectTo    []Content
21496                                 InsideTint   color.NRGBA
21497                                 Level        uint8 // Must be < 128.
21498
21499                                 Translucent bool // Sunlight is scattered and becomes normal light.
21500                                 Transparent bool // Sunlight isn't scattered.
21501                                 LightSrc    uint8
21502
21503                                 GndContent   bool
21504                                 Collides     bool
21505                                 Pointable    bool
21506                                 Diggable     bool
21507                                 Climbable    bool
21508                                 Replaceable  bool
21509                                 OnRightClick bool
21510
21511                                 DmgPerSec int32
21512
21513                                 LiquidType   LiquidType
21514                                 FlowingAlt   string
21515                                 SrcAlt       string
21516                                 Viscosity    uint8 // 0-7
21517                                 LiqRenewable bool
21518                                 FlowRange    uint8
21519                                 DrownDmg     uint8
21520                                 Floodable    bool
21521
21522                                 DrawBox, ColBox, SelBox NodeBox
21523
21524                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21525
21526                                 LegacyFaceDir bool
21527                                 LegacyMounted bool
21528
21529                                 DigPredict string
21530
21531                                 MaxLvl uint8
21532
21533                                 AlphaUse
21534                         }))(obj)).Floodable
21535                         switch n := read8(r); n {
21536                         case 0:
21537                                 *p = false
21538                         case 1:
21539                                 *p = true
21540                         default:
21541                                 chk(fmt.Errorf("invalid bool: %d", n))
21542                         }
21543
21544                 }
21545                 if err := pcall(func() {
21546                         ((*(*(struct {
21547                                 Param0 Content
21548
21549                                 Name   string
21550                                 Groups []Group
21551
21552                                 P1Type   Param1Type
21553                                 P2Type   Param2Type
21554                                 DrawType DrawType
21555
21556                                 Mesh  string
21557                                 Scale float32
21558                                 //mt:const uint8(6)
21559                                 Tiles        [6]TileDef
21560                                 OverlayTiles [6]TileDef
21561                                 //mt:const uint8(6)
21562                                 SpecialTiles [6]TileDef
21563
21564                                 Color   color.NRGBA
21565                                 Palette Texture
21566
21567                                 Waving       WaveType
21568                                 ConnectSides uint8
21569                                 ConnectTo    []Content
21570                                 InsideTint   color.NRGBA
21571                                 Level        uint8 // Must be < 128.
21572
21573                                 Translucent bool // Sunlight is scattered and becomes normal light.
21574                                 Transparent bool // Sunlight isn't scattered.
21575                                 LightSrc    uint8
21576
21577                                 GndContent   bool
21578                                 Collides     bool
21579                                 Pointable    bool
21580                                 Diggable     bool
21581                                 Climbable    bool
21582                                 Replaceable  bool
21583                                 OnRightClick bool
21584
21585                                 DmgPerSec int32
21586
21587                                 LiquidType   LiquidType
21588                                 FlowingAlt   string
21589                                 SrcAlt       string
21590                                 Viscosity    uint8 // 0-7
21591                                 LiqRenewable bool
21592                                 FlowRange    uint8
21593                                 DrownDmg     uint8
21594                                 Floodable    bool
21595
21596                                 DrawBox, ColBox, SelBox NodeBox
21597
21598                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21599
21600                                 LegacyFaceDir bool
21601                                 LegacyMounted bool
21602
21603                                 DigPredict string
21604
21605                                 MaxLvl uint8
21606
21607                                 AlphaUse
21608                         }))(obj)).DrawBox).deserialize(r)
21609                 }); err != nil {
21610                         if err == io.EOF {
21611                                 chk(io.EOF)
21612                         }
21613                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
21614                 }
21615                 if err := pcall(func() {
21616                         ((*(*(struct {
21617                                 Param0 Content
21618
21619                                 Name   string
21620                                 Groups []Group
21621
21622                                 P1Type   Param1Type
21623                                 P2Type   Param2Type
21624                                 DrawType DrawType
21625
21626                                 Mesh  string
21627                                 Scale float32
21628                                 //mt:const uint8(6)
21629                                 Tiles        [6]TileDef
21630                                 OverlayTiles [6]TileDef
21631                                 //mt:const uint8(6)
21632                                 SpecialTiles [6]TileDef
21633
21634                                 Color   color.NRGBA
21635                                 Palette Texture
21636
21637                                 Waving       WaveType
21638                                 ConnectSides uint8
21639                                 ConnectTo    []Content
21640                                 InsideTint   color.NRGBA
21641                                 Level        uint8 // Must be < 128.
21642
21643                                 Translucent bool // Sunlight is scattered and becomes normal light.
21644                                 Transparent bool // Sunlight isn't scattered.
21645                                 LightSrc    uint8
21646
21647                                 GndContent   bool
21648                                 Collides     bool
21649                                 Pointable    bool
21650                                 Diggable     bool
21651                                 Climbable    bool
21652                                 Replaceable  bool
21653                                 OnRightClick bool
21654
21655                                 DmgPerSec int32
21656
21657                                 LiquidType   LiquidType
21658                                 FlowingAlt   string
21659                                 SrcAlt       string
21660                                 Viscosity    uint8 // 0-7
21661                                 LiqRenewable bool
21662                                 FlowRange    uint8
21663                                 DrownDmg     uint8
21664                                 Floodable    bool
21665
21666                                 DrawBox, ColBox, SelBox NodeBox
21667
21668                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21669
21670                                 LegacyFaceDir bool
21671                                 LegacyMounted bool
21672
21673                                 DigPredict string
21674
21675                                 MaxLvl uint8
21676
21677                                 AlphaUse
21678                         }))(obj)).ColBox).deserialize(r)
21679                 }); err != nil {
21680                         if err == io.EOF {
21681                                 chk(io.EOF)
21682                         }
21683                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
21684                 }
21685                 if err := pcall(func() {
21686                         ((*(*(struct {
21687                                 Param0 Content
21688
21689                                 Name   string
21690                                 Groups []Group
21691
21692                                 P1Type   Param1Type
21693                                 P2Type   Param2Type
21694                                 DrawType DrawType
21695
21696                                 Mesh  string
21697                                 Scale float32
21698                                 //mt:const uint8(6)
21699                                 Tiles        [6]TileDef
21700                                 OverlayTiles [6]TileDef
21701                                 //mt:const uint8(6)
21702                                 SpecialTiles [6]TileDef
21703
21704                                 Color   color.NRGBA
21705                                 Palette Texture
21706
21707                                 Waving       WaveType
21708                                 ConnectSides uint8
21709                                 ConnectTo    []Content
21710                                 InsideTint   color.NRGBA
21711                                 Level        uint8 // Must be < 128.
21712
21713                                 Translucent bool // Sunlight is scattered and becomes normal light.
21714                                 Transparent bool // Sunlight isn't scattered.
21715                                 LightSrc    uint8
21716
21717                                 GndContent   bool
21718                                 Collides     bool
21719                                 Pointable    bool
21720                                 Diggable     bool
21721                                 Climbable    bool
21722                                 Replaceable  bool
21723                                 OnRightClick bool
21724
21725                                 DmgPerSec int32
21726
21727                                 LiquidType   LiquidType
21728                                 FlowingAlt   string
21729                                 SrcAlt       string
21730                                 Viscosity    uint8 // 0-7
21731                                 LiqRenewable bool
21732                                 FlowRange    uint8
21733                                 DrownDmg     uint8
21734                                 Floodable    bool
21735
21736                                 DrawBox, ColBox, SelBox NodeBox
21737
21738                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21739
21740                                 LegacyFaceDir bool
21741                                 LegacyMounted bool
21742
21743                                 DigPredict string
21744
21745                                 MaxLvl uint8
21746
21747                                 AlphaUse
21748                         }))(obj)).SelBox).deserialize(r)
21749                 }); err != nil {
21750                         if err == io.EOF {
21751                                 chk(io.EOF)
21752                         }
21753                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBox", err))
21754                 }
21755                 if err := pcall(func() {
21756                         ((*(*(struct {
21757                                 Param0 Content
21758
21759                                 Name   string
21760                                 Groups []Group
21761
21762                                 P1Type   Param1Type
21763                                 P2Type   Param2Type
21764                                 DrawType DrawType
21765
21766                                 Mesh  string
21767                                 Scale float32
21768                                 //mt:const uint8(6)
21769                                 Tiles        [6]TileDef
21770                                 OverlayTiles [6]TileDef
21771                                 //mt:const uint8(6)
21772                                 SpecialTiles [6]TileDef
21773
21774                                 Color   color.NRGBA
21775                                 Palette Texture
21776
21777                                 Waving       WaveType
21778                                 ConnectSides uint8
21779                                 ConnectTo    []Content
21780                                 InsideTint   color.NRGBA
21781                                 Level        uint8 // Must be < 128.
21782
21783                                 Translucent bool // Sunlight is scattered and becomes normal light.
21784                                 Transparent bool // Sunlight isn't scattered.
21785                                 LightSrc    uint8
21786
21787                                 GndContent   bool
21788                                 Collides     bool
21789                                 Pointable    bool
21790                                 Diggable     bool
21791                                 Climbable    bool
21792                                 Replaceable  bool
21793                                 OnRightClick bool
21794
21795                                 DmgPerSec int32
21796
21797                                 LiquidType   LiquidType
21798                                 FlowingAlt   string
21799                                 SrcAlt       string
21800                                 Viscosity    uint8 // 0-7
21801                                 LiqRenewable bool
21802                                 FlowRange    uint8
21803                                 DrownDmg     uint8
21804                                 Floodable    bool
21805
21806                                 DrawBox, ColBox, SelBox NodeBox
21807
21808                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21809
21810                                 LegacyFaceDir bool
21811                                 LegacyMounted bool
21812
21813                                 DigPredict string
21814
21815                                 MaxLvl uint8
21816
21817                                 AlphaUse
21818                         }))(obj)).FootstepSnd).deserialize(r)
21819                 }); err != nil {
21820                         if err == io.EOF {
21821                                 chk(io.EOF)
21822                         }
21823                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
21824                 }
21825                 if err := pcall(func() {
21826                         ((*(*(struct {
21827                                 Param0 Content
21828
21829                                 Name   string
21830                                 Groups []Group
21831
21832                                 P1Type   Param1Type
21833                                 P2Type   Param2Type
21834                                 DrawType DrawType
21835
21836                                 Mesh  string
21837                                 Scale float32
21838                                 //mt:const uint8(6)
21839                                 Tiles        [6]TileDef
21840                                 OverlayTiles [6]TileDef
21841                                 //mt:const uint8(6)
21842                                 SpecialTiles [6]TileDef
21843
21844                                 Color   color.NRGBA
21845                                 Palette Texture
21846
21847                                 Waving       WaveType
21848                                 ConnectSides uint8
21849                                 ConnectTo    []Content
21850                                 InsideTint   color.NRGBA
21851                                 Level        uint8 // Must be < 128.
21852
21853                                 Translucent bool // Sunlight is scattered and becomes normal light.
21854                                 Transparent bool // Sunlight isn't scattered.
21855                                 LightSrc    uint8
21856
21857                                 GndContent   bool
21858                                 Collides     bool
21859                                 Pointable    bool
21860                                 Diggable     bool
21861                                 Climbable    bool
21862                                 Replaceable  bool
21863                                 OnRightClick bool
21864
21865                                 DmgPerSec int32
21866
21867                                 LiquidType   LiquidType
21868                                 FlowingAlt   string
21869                                 SrcAlt       string
21870                                 Viscosity    uint8 // 0-7
21871                                 LiqRenewable bool
21872                                 FlowRange    uint8
21873                                 DrownDmg     uint8
21874                                 Floodable    bool
21875
21876                                 DrawBox, ColBox, SelBox NodeBox
21877
21878                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21879
21880                                 LegacyFaceDir bool
21881                                 LegacyMounted bool
21882
21883                                 DigPredict string
21884
21885                                 MaxLvl uint8
21886
21887                                 AlphaUse
21888                         }))(obj)).DiggingSnd).deserialize(r)
21889                 }); err != nil {
21890                         if err == io.EOF {
21891                                 chk(io.EOF)
21892                         }
21893                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
21894                 }
21895                 if err := pcall(func() {
21896                         ((*(*(struct {
21897                                 Param0 Content
21898
21899                                 Name   string
21900                                 Groups []Group
21901
21902                                 P1Type   Param1Type
21903                                 P2Type   Param2Type
21904                                 DrawType DrawType
21905
21906                                 Mesh  string
21907                                 Scale float32
21908                                 //mt:const uint8(6)
21909                                 Tiles        [6]TileDef
21910                                 OverlayTiles [6]TileDef
21911                                 //mt:const uint8(6)
21912                                 SpecialTiles [6]TileDef
21913
21914                                 Color   color.NRGBA
21915                                 Palette Texture
21916
21917                                 Waving       WaveType
21918                                 ConnectSides uint8
21919                                 ConnectTo    []Content
21920                                 InsideTint   color.NRGBA
21921                                 Level        uint8 // Must be < 128.
21922
21923                                 Translucent bool // Sunlight is scattered and becomes normal light.
21924                                 Transparent bool // Sunlight isn't scattered.
21925                                 LightSrc    uint8
21926
21927                                 GndContent   bool
21928                                 Collides     bool
21929                                 Pointable    bool
21930                                 Diggable     bool
21931                                 Climbable    bool
21932                                 Replaceable  bool
21933                                 OnRightClick bool
21934
21935                                 DmgPerSec int32
21936
21937                                 LiquidType   LiquidType
21938                                 FlowingAlt   string
21939                                 SrcAlt       string
21940                                 Viscosity    uint8 // 0-7
21941                                 LiqRenewable bool
21942                                 FlowRange    uint8
21943                                 DrownDmg     uint8
21944                                 Floodable    bool
21945
21946                                 DrawBox, ColBox, SelBox NodeBox
21947
21948                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21949
21950                                 LegacyFaceDir bool
21951                                 LegacyMounted bool
21952
21953                                 DigPredict string
21954
21955                                 MaxLvl uint8
21956
21957                                 AlphaUse
21958                         }))(obj)).DugSnd).deserialize(r)
21959                 }); err != nil {
21960                         if err == io.EOF {
21961                                 chk(io.EOF)
21962                         }
21963                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
21964                 }
21965                 {
21966                         p := &(*(*(struct {
21967                                 Param0 Content
21968
21969                                 Name   string
21970                                 Groups []Group
21971
21972                                 P1Type   Param1Type
21973                                 P2Type   Param2Type
21974                                 DrawType DrawType
21975
21976                                 Mesh  string
21977                                 Scale float32
21978                                 //mt:const uint8(6)
21979                                 Tiles        [6]TileDef
21980                                 OverlayTiles [6]TileDef
21981                                 //mt:const uint8(6)
21982                                 SpecialTiles [6]TileDef
21983
21984                                 Color   color.NRGBA
21985                                 Palette Texture
21986
21987                                 Waving       WaveType
21988                                 ConnectSides uint8
21989                                 ConnectTo    []Content
21990                                 InsideTint   color.NRGBA
21991                                 Level        uint8 // Must be < 128.
21992
21993                                 Translucent bool // Sunlight is scattered and becomes normal light.
21994                                 Transparent bool // Sunlight isn't scattered.
21995                                 LightSrc    uint8
21996
21997                                 GndContent   bool
21998                                 Collides     bool
21999                                 Pointable    bool
22000                                 Diggable     bool
22001                                 Climbable    bool
22002                                 Replaceable  bool
22003                                 OnRightClick bool
22004
22005                                 DmgPerSec int32
22006
22007                                 LiquidType   LiquidType
22008                                 FlowingAlt   string
22009                                 SrcAlt       string
22010                                 Viscosity    uint8 // 0-7
22011                                 LiqRenewable bool
22012                                 FlowRange    uint8
22013                                 DrownDmg     uint8
22014                                 Floodable    bool
22015
22016                                 DrawBox, ColBox, SelBox NodeBox
22017
22018                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22019
22020                                 LegacyFaceDir bool
22021                                 LegacyMounted bool
22022
22023                                 DigPredict string
22024
22025                                 MaxLvl uint8
22026
22027                                 AlphaUse
22028                         }))(obj)).LegacyFaceDir
22029                         switch n := read8(r); n {
22030                         case 0:
22031                                 *p = false
22032                         case 1:
22033                                 *p = true
22034                         default:
22035                                 chk(fmt.Errorf("invalid bool: %d", n))
22036                         }
22037
22038                 }
22039                 {
22040                         p := &(*(*(struct {
22041                                 Param0 Content
22042
22043                                 Name   string
22044                                 Groups []Group
22045
22046                                 P1Type   Param1Type
22047                                 P2Type   Param2Type
22048                                 DrawType DrawType
22049
22050                                 Mesh  string
22051                                 Scale float32
22052                                 //mt:const uint8(6)
22053                                 Tiles        [6]TileDef
22054                                 OverlayTiles [6]TileDef
22055                                 //mt:const uint8(6)
22056                                 SpecialTiles [6]TileDef
22057
22058                                 Color   color.NRGBA
22059                                 Palette Texture
22060
22061                                 Waving       WaveType
22062                                 ConnectSides uint8
22063                                 ConnectTo    []Content
22064                                 InsideTint   color.NRGBA
22065                                 Level        uint8 // Must be < 128.
22066
22067                                 Translucent bool // Sunlight is scattered and becomes normal light.
22068                                 Transparent bool // Sunlight isn't scattered.
22069                                 LightSrc    uint8
22070
22071                                 GndContent   bool
22072                                 Collides     bool
22073                                 Pointable    bool
22074                                 Diggable     bool
22075                                 Climbable    bool
22076                                 Replaceable  bool
22077                                 OnRightClick bool
22078
22079                                 DmgPerSec int32
22080
22081                                 LiquidType   LiquidType
22082                                 FlowingAlt   string
22083                                 SrcAlt       string
22084                                 Viscosity    uint8 // 0-7
22085                                 LiqRenewable bool
22086                                 FlowRange    uint8
22087                                 DrownDmg     uint8
22088                                 Floodable    bool
22089
22090                                 DrawBox, ColBox, SelBox NodeBox
22091
22092                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22093
22094                                 LegacyFaceDir bool
22095                                 LegacyMounted bool
22096
22097                                 DigPredict string
22098
22099                                 MaxLvl uint8
22100
22101                                 AlphaUse
22102                         }))(obj)).LegacyMounted
22103                         switch n := read8(r); n {
22104                         case 0:
22105                                 *p = false
22106                         case 1:
22107                                 *p = true
22108                         default:
22109                                 chk(fmt.Errorf("invalid bool: %d", n))
22110                         }
22111
22112                 }
22113                 var local267 []uint8
22114                 var local268 uint16
22115                 {
22116                         p := &local268
22117                         *p = read16(r)
22118                 }
22119                 (local267) = make([]uint8, local268)
22120                 {
22121                         _, err := io.ReadFull(r, (local267)[:])
22122                         chk(err)
22123                 }
22124                 ((*(*(struct {
22125                         Param0 Content
22126
22127                         Name   string
22128                         Groups []Group
22129
22130                         P1Type   Param1Type
22131                         P2Type   Param2Type
22132                         DrawType DrawType
22133
22134                         Mesh  string
22135                         Scale float32
22136                         //mt:const uint8(6)
22137                         Tiles        [6]TileDef
22138                         OverlayTiles [6]TileDef
22139                         //mt:const uint8(6)
22140                         SpecialTiles [6]TileDef
22141
22142                         Color   color.NRGBA
22143                         Palette Texture
22144
22145                         Waving       WaveType
22146                         ConnectSides uint8
22147                         ConnectTo    []Content
22148                         InsideTint   color.NRGBA
22149                         Level        uint8 // Must be < 128.
22150
22151                         Translucent bool // Sunlight is scattered and becomes normal light.
22152                         Transparent bool // Sunlight isn't scattered.
22153                         LightSrc    uint8
22154
22155                         GndContent   bool
22156                         Collides     bool
22157                         Pointable    bool
22158                         Diggable     bool
22159                         Climbable    bool
22160                         Replaceable  bool
22161                         OnRightClick bool
22162
22163                         DmgPerSec int32
22164
22165                         LiquidType   LiquidType
22166                         FlowingAlt   string
22167                         SrcAlt       string
22168                         Viscosity    uint8 // 0-7
22169                         LiqRenewable bool
22170                         FlowRange    uint8
22171                         DrownDmg     uint8
22172                         Floodable    bool
22173
22174                         DrawBox, ColBox, SelBox NodeBox
22175
22176                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22177
22178                         LegacyFaceDir bool
22179                         LegacyMounted bool
22180
22181                         DigPredict string
22182
22183                         MaxLvl uint8
22184
22185                         AlphaUse
22186                 }))(obj)).DigPredict) = string(local267)
22187                 {
22188                         p := &(*(*(struct {
22189                                 Param0 Content
22190
22191                                 Name   string
22192                                 Groups []Group
22193
22194                                 P1Type   Param1Type
22195                                 P2Type   Param2Type
22196                                 DrawType DrawType
22197
22198                                 Mesh  string
22199                                 Scale float32
22200                                 //mt:const uint8(6)
22201                                 Tiles        [6]TileDef
22202                                 OverlayTiles [6]TileDef
22203                                 //mt:const uint8(6)
22204                                 SpecialTiles [6]TileDef
22205
22206                                 Color   color.NRGBA
22207                                 Palette Texture
22208
22209                                 Waving       WaveType
22210                                 ConnectSides uint8
22211                                 ConnectTo    []Content
22212                                 InsideTint   color.NRGBA
22213                                 Level        uint8 // Must be < 128.
22214
22215                                 Translucent bool // Sunlight is scattered and becomes normal light.
22216                                 Transparent bool // Sunlight isn't scattered.
22217                                 LightSrc    uint8
22218
22219                                 GndContent   bool
22220                                 Collides     bool
22221                                 Pointable    bool
22222                                 Diggable     bool
22223                                 Climbable    bool
22224                                 Replaceable  bool
22225                                 OnRightClick bool
22226
22227                                 DmgPerSec int32
22228
22229                                 LiquidType   LiquidType
22230                                 FlowingAlt   string
22231                                 SrcAlt       string
22232                                 Viscosity    uint8 // 0-7
22233                                 LiqRenewable bool
22234                                 FlowRange    uint8
22235                                 DrownDmg     uint8
22236                                 Floodable    bool
22237
22238                                 DrawBox, ColBox, SelBox NodeBox
22239
22240                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22241
22242                                 LegacyFaceDir bool
22243                                 LegacyMounted bool
22244
22245                                 DigPredict string
22246
22247                                 MaxLvl uint8
22248
22249                                 AlphaUse
22250                         }))(obj)).MaxLvl
22251                         *p = read8(r)
22252                 }
22253                 if err := pcall(func() {
22254                         ((*(*(struct {
22255                                 Param0 Content
22256
22257                                 Name   string
22258                                 Groups []Group
22259
22260                                 P1Type   Param1Type
22261                                 P2Type   Param2Type
22262                                 DrawType DrawType
22263
22264                                 Mesh  string
22265                                 Scale float32
22266                                 //mt:const uint8(6)
22267                                 Tiles        [6]TileDef
22268                                 OverlayTiles [6]TileDef
22269                                 //mt:const uint8(6)
22270                                 SpecialTiles [6]TileDef
22271
22272                                 Color   color.NRGBA
22273                                 Palette Texture
22274
22275                                 Waving       WaveType
22276                                 ConnectSides uint8
22277                                 ConnectTo    []Content
22278                                 InsideTint   color.NRGBA
22279                                 Level        uint8 // Must be < 128.
22280
22281                                 Translucent bool // Sunlight is scattered and becomes normal light.
22282                                 Transparent bool // Sunlight isn't scattered.
22283                                 LightSrc    uint8
22284
22285                                 GndContent   bool
22286                                 Collides     bool
22287                                 Pointable    bool
22288                                 Diggable     bool
22289                                 Climbable    bool
22290                                 Replaceable  bool
22291                                 OnRightClick bool
22292
22293                                 DmgPerSec int32
22294
22295                                 LiquidType   LiquidType
22296                                 FlowingAlt   string
22297                                 SrcAlt       string
22298                                 Viscosity    uint8 // 0-7
22299                                 LiqRenewable bool
22300                                 FlowRange    uint8
22301                                 DrownDmg     uint8
22302                                 Floodable    bool
22303
22304                                 DrawBox, ColBox, SelBox NodeBox
22305
22306                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22307
22308                                 LegacyFaceDir bool
22309                                 LegacyMounted bool
22310
22311                                 DigPredict string
22312
22313                                 MaxLvl uint8
22314
22315                                 AlphaUse
22316                         }))(obj)).AlphaUse).deserialize(r)
22317                 }); err != nil {
22318                         if err == io.EOF {
22319                                 chk(io.EOF)
22320                         }
22321                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlphaUse", err))
22322                 }
22323                 if r.N > 0 {
22324                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
22325                 }
22326         }
22327 }
22328
22329 func (obj *PointedNode) serialize(w io.Writer) {
22330         for local269 := range (*(*(struct {
22331                 Under, Above [3]int16
22332         }))(obj)).Under {
22333                 {
22334                         x := ((*(*(struct {
22335                                 Under, Above [3]int16
22336                         }))(obj)).Under)[local269]
22337                         write16(w, uint16(x))
22338                 }
22339         }
22340         for local270 := range (*(*(struct {
22341                 Under, Above [3]int16
22342         }))(obj)).Above {
22343                 {
22344                         x := ((*(*(struct {
22345                                 Under, Above [3]int16
22346                         }))(obj)).Above)[local270]
22347                         write16(w, uint16(x))
22348                 }
22349         }
22350 }
22351
22352 func (obj *PointedNode) deserialize(r io.Reader) {
22353         for local271 := range (*(*(struct {
22354                 Under, Above [3]int16
22355         }))(obj)).Under {
22356                 {
22357                         p := &((*(*(struct {
22358                                 Under, Above [3]int16
22359                         }))(obj)).Under)[local271]
22360                         *p = int16(read16(r))
22361                 }
22362         }
22363         for local272 := range (*(*(struct {
22364                 Under, Above [3]int16
22365         }))(obj)).Above {
22366                 {
22367                         p := &((*(*(struct {
22368                                 Under, Above [3]int16
22369                         }))(obj)).Above)[local272]
22370                         *p = int16(read16(r))
22371                 }
22372         }
22373 }
22374
22375 func (obj *PointedAO) serialize(w io.Writer) {
22376         if err := pcall(func() {
22377                 ((*(*(struct {
22378                         ID AOID
22379                 }))(obj)).ID).serialize(w)
22380         }); err != nil {
22381                 if err == io.EOF {
22382                         chk(io.EOF)
22383                 }
22384                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
22385         }
22386 }
22387
22388 func (obj *PointedAO) deserialize(r io.Reader) {
22389         if err := pcall(func() {
22390                 ((*(*(struct {
22391                         ID AOID
22392                 }))(obj)).ID).deserialize(r)
22393         }); err != nil {
22394                 if err == io.EOF {
22395                         chk(io.EOF)
22396                 }
22397                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
22398         }
22399 }
22400
22401 func (obj *CompressionModes) serialize(w io.Writer) {
22402         {
22403                 x := *(*(uint16))(obj)
22404                 write16(w, uint16(x))
22405         }
22406 }
22407
22408 func (obj *CompressionModes) deserialize(r io.Reader) {
22409         {
22410                 p := &*(*(uint16))(obj)
22411                 *p = read16(r)
22412         }
22413 }
22414
22415 func (obj *PlayerPos) serialize(w io.Writer) {
22416         for local273 := range (*(*(struct {
22417                 Pos100, Vel100   [3]int32
22418                 Pitch100, Yaw100 int32
22419                 Keys             Keys
22420                 FOV80            uint8
22421                 WantedRange      uint8 // in MapBlks.
22422         }))(obj)).Pos100 {
22423                 {
22424                         x := ((*(*(struct {
22425                                 Pos100, Vel100   [3]int32
22426                                 Pitch100, Yaw100 int32
22427                                 Keys             Keys
22428                                 FOV80            uint8
22429                                 WantedRange      uint8 // in MapBlks.
22430                         }))(obj)).Pos100)[local273]
22431                         write32(w, uint32(x))
22432                 }
22433         }
22434         for local274 := range (*(*(struct {
22435                 Pos100, Vel100   [3]int32
22436                 Pitch100, Yaw100 int32
22437                 Keys             Keys
22438                 FOV80            uint8
22439                 WantedRange      uint8 // in MapBlks.
22440         }))(obj)).Vel100 {
22441                 {
22442                         x := ((*(*(struct {
22443                                 Pos100, Vel100   [3]int32
22444                                 Pitch100, Yaw100 int32
22445                                 Keys             Keys
22446                                 FOV80            uint8
22447                                 WantedRange      uint8 // in MapBlks.
22448                         }))(obj)).Vel100)[local274]
22449                         write32(w, uint32(x))
22450                 }
22451         }
22452         {
22453                 x := (*(*(struct {
22454                         Pos100, Vel100   [3]int32
22455                         Pitch100, Yaw100 int32
22456                         Keys             Keys
22457                         FOV80            uint8
22458                         WantedRange      uint8 // in MapBlks.
22459                 }))(obj)).Pitch100
22460                 write32(w, uint32(x))
22461         }
22462         {
22463                 x := (*(*(struct {
22464                         Pos100, Vel100   [3]int32
22465                         Pitch100, Yaw100 int32
22466                         Keys             Keys
22467                         FOV80            uint8
22468                         WantedRange      uint8 // in MapBlks.
22469                 }))(obj)).Yaw100
22470                 write32(w, uint32(x))
22471         }
22472         if err := pcall(func() {
22473                 ((*(*(struct {
22474                         Pos100, Vel100   [3]int32
22475                         Pitch100, Yaw100 int32
22476                         Keys             Keys
22477                         FOV80            uint8
22478                         WantedRange      uint8 // in MapBlks.
22479                 }))(obj)).Keys).serialize(w)
22480         }); err != nil {
22481                 if err == io.EOF {
22482                         chk(io.EOF)
22483                 }
22484                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Keys", err))
22485         }
22486         {
22487                 x := (*(*(struct {
22488                         Pos100, Vel100   [3]int32
22489                         Pitch100, Yaw100 int32
22490                         Keys             Keys
22491                         FOV80            uint8
22492                         WantedRange      uint8 // in MapBlks.
22493                 }))(obj)).FOV80
22494                 write8(w, uint8(x))
22495         }
22496         {
22497                 x := (*(*(struct {
22498                         Pos100, Vel100   [3]int32
22499                         Pitch100, Yaw100 int32
22500                         Keys             Keys
22501                         FOV80            uint8
22502                         WantedRange      uint8 // in MapBlks.
22503                 }))(obj)).WantedRange
22504                 write8(w, uint8(x))
22505         }
22506 }
22507
22508 func (obj *PlayerPos) deserialize(r io.Reader) {
22509         for local275 := range (*(*(struct {
22510                 Pos100, Vel100   [3]int32
22511                 Pitch100, Yaw100 int32
22512                 Keys             Keys
22513                 FOV80            uint8
22514                 WantedRange      uint8 // in MapBlks.
22515         }))(obj)).Pos100 {
22516                 {
22517                         p := &((*(*(struct {
22518                                 Pos100, Vel100   [3]int32
22519                                 Pitch100, Yaw100 int32
22520                                 Keys             Keys
22521                                 FOV80            uint8
22522                                 WantedRange      uint8 // in MapBlks.
22523                         }))(obj)).Pos100)[local275]
22524                         *p = int32(read32(r))
22525                 }
22526         }
22527         for local276 := range (*(*(struct {
22528                 Pos100, Vel100   [3]int32
22529                 Pitch100, Yaw100 int32
22530                 Keys             Keys
22531                 FOV80            uint8
22532                 WantedRange      uint8 // in MapBlks.
22533         }))(obj)).Vel100 {
22534                 {
22535                         p := &((*(*(struct {
22536                                 Pos100, Vel100   [3]int32
22537                                 Pitch100, Yaw100 int32
22538                                 Keys             Keys
22539                                 FOV80            uint8
22540                                 WantedRange      uint8 // in MapBlks.
22541                         }))(obj)).Vel100)[local276]
22542                         *p = int32(read32(r))
22543                 }
22544         }
22545         {
22546                 p := &(*(*(struct {
22547                         Pos100, Vel100   [3]int32
22548                         Pitch100, Yaw100 int32
22549                         Keys             Keys
22550                         FOV80            uint8
22551                         WantedRange      uint8 // in MapBlks.
22552                 }))(obj)).Pitch100
22553                 *p = int32(read32(r))
22554         }
22555         {
22556                 p := &(*(*(struct {
22557                         Pos100, Vel100   [3]int32
22558                         Pitch100, Yaw100 int32
22559                         Keys             Keys
22560                         FOV80            uint8
22561                         WantedRange      uint8 // in MapBlks.
22562                 }))(obj)).Yaw100
22563                 *p = int32(read32(r))
22564         }
22565         if err := pcall(func() {
22566                 ((*(*(struct {
22567                         Pos100, Vel100   [3]int32
22568                         Pitch100, Yaw100 int32
22569                         Keys             Keys
22570                         FOV80            uint8
22571                         WantedRange      uint8 // in MapBlks.
22572                 }))(obj)).Keys).deserialize(r)
22573         }); err != nil {
22574                 if err == io.EOF {
22575                         chk(io.EOF)
22576                 }
22577                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Keys", err))
22578         }
22579         {
22580                 p := &(*(*(struct {
22581                         Pos100, Vel100   [3]int32
22582                         Pitch100, Yaw100 int32
22583                         Keys             Keys
22584                         FOV80            uint8
22585                         WantedRange      uint8 // in MapBlks.
22586                 }))(obj)).FOV80
22587                 *p = read8(r)
22588         }
22589         {
22590                 p := &(*(*(struct {
22591                         Pos100, Vel100   [3]int32
22592                         Pitch100, Yaw100 int32
22593                         Keys             Keys
22594                         FOV80            uint8
22595                         WantedRange      uint8 // in MapBlks.
22596                 }))(obj)).WantedRange
22597                 *p = read8(r)
22598         }
22599 }
22600
22601 func (obj *Interaction) serialize(w io.Writer) {
22602         {
22603                 x := *(*(uint8))(obj)
22604                 write8(w, uint8(x))
22605         }
22606 }
22607
22608 func (obj *Interaction) deserialize(r io.Reader) {
22609         {
22610                 p := &*(*(uint8))(obj)
22611                 *p = read8(r)
22612         }
22613 }
22614
22615 func (obj *SoundID) serialize(w io.Writer) {
22616         {
22617                 x := *(*(int32))(obj)
22618                 write32(w, uint32(x))
22619         }
22620 }
22621
22622 func (obj *SoundID) deserialize(r io.Reader) {
22623         {
22624                 p := &*(*(int32))(obj)
22625                 *p = int32(read32(r))
22626         }
22627 }
22628
22629 func (obj *Field) serialize(w io.Writer) {
22630         if len(([]byte((*(*(struct {
22631                 Name string
22632
22633                 //mt:len32
22634                 Value string
22635         }))(obj)).Name))) > math.MaxUint16 {
22636                 chk(ErrTooLong)
22637         }
22638         {
22639                 x := uint16(len(([]byte((*(*(struct {
22640                         Name string
22641
22642                         //mt:len32
22643                         Value string
22644                 }))(obj)).Name))))
22645                 write16(w, uint16(x))
22646         }
22647         {
22648                 _, err := w.Write(([]byte((*(*(struct {
22649                         Name string
22650
22651                         //mt:len32
22652                         Value string
22653                 }))(obj)).Name))[:])
22654                 chk(err)
22655         }
22656         if len(([]byte((*(*(struct {
22657                 Name string
22658
22659                 //mt:len32
22660                 Value string
22661         }))(obj)).Value))) > math.MaxUint32 {
22662                 chk(ErrTooLong)
22663         }
22664         {
22665                 x := uint32(len(([]byte((*(*(struct {
22666                         Name string
22667
22668                         //mt:len32
22669                         Value string
22670                 }))(obj)).Value))))
22671                 write32(w, uint32(x))
22672         }
22673         {
22674                 _, err := w.Write(([]byte((*(*(struct {
22675                         Name string
22676
22677                         //mt:len32
22678                         Value string
22679                 }))(obj)).Value))[:])
22680                 chk(err)
22681         }
22682 }
22683
22684 func (obj *Field) deserialize(r io.Reader) {
22685         var local277 []uint8
22686         var local278 uint16
22687         {
22688                 p := &local278
22689                 *p = read16(r)
22690         }
22691         (local277) = make([]uint8, local278)
22692         {
22693                 _, err := io.ReadFull(r, (local277)[:])
22694                 chk(err)
22695         }
22696         ((*(*(struct {
22697                 Name string
22698
22699                 //mt:len32
22700                 Value string
22701         }))(obj)).Name) = string(local277)
22702         var local279 []uint8
22703         var local280 uint32
22704         {
22705                 p := &local280
22706                 *p = read32(r)
22707         }
22708         (local279) = make([]uint8, local280)
22709         {
22710                 _, err := io.ReadFull(r, (local279)[:])
22711                 chk(err)
22712         }
22713         ((*(*(struct {
22714                 Name string
22715
22716                 //mt:len32
22717                 Value string
22718         }))(obj)).Value) = string(local279)
22719 }
22720
22721 func (obj *AuthMethods) serialize(w io.Writer) {
22722         {
22723                 x := *(*(uint32))(obj)
22724                 write32(w, uint32(x))
22725         }
22726 }
22727
22728 func (obj *AuthMethods) deserialize(r io.Reader) {
22729         {
22730                 p := &*(*(uint32))(obj)
22731                 *p = read32(r)
22732         }
22733 }
22734
22735 func (obj *Pos) serialize(w io.Writer) {
22736         if err := pcall(func() {
22737                 (*(*(Vec))(obj)).serialize(w)
22738         }); err != nil {
22739                 if err == io.EOF {
22740                         chk(io.EOF)
22741                 }
22742                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
22743         }
22744 }
22745
22746 func (obj *Pos) deserialize(r io.Reader) {
22747         if err := pcall(func() {
22748                 (*(*(Vec))(obj)).deserialize(r)
22749         }); err != nil {
22750                 if err == io.EOF {
22751                         chk(io.EOF)
22752                 }
22753                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
22754         }
22755 }
22756
22757 func (obj *KickReason) serialize(w io.Writer) {
22758         {
22759                 x := *(*(uint8))(obj)
22760                 write8(w, uint8(x))
22761         }
22762 }
22763
22764 func (obj *KickReason) deserialize(r io.Reader) {
22765         {
22766                 p := &*(*(uint8))(obj)
22767                 *p = read8(r)
22768         }
22769 }
22770
22771 func (obj *MapBlk) serialize(w io.Writer) {
22772         if err := pcall(func() {
22773                 ((*(*(struct {
22774                         Flags   MapBlkFlags
22775                         LitFrom LitFromBlks
22776
22777                         //mt:zstd
22778                         Param0 [4096]Content
22779                         Param1 [4096]uint8
22780                         Param2 [4096]uint8
22781
22782                         NodeMetas map[uint16]*NodeMeta
22783                 }))(obj)).Flags).serialize(w)
22784         }); err != nil {
22785                 if err == io.EOF {
22786                         chk(io.EOF)
22787                 }
22788                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlkFlags", err))
22789         }
22790         if err := pcall(func() {
22791                 ((*(*(struct {
22792                         Flags   MapBlkFlags
22793                         LitFrom LitFromBlks
22794
22795                         //mt:zstd
22796                         Param0 [4096]Content
22797                         Param1 [4096]uint8
22798                         Param2 [4096]uint8
22799
22800                         NodeMetas map[uint16]*NodeMeta
22801                 }))(obj)).LitFrom).serialize(w)
22802         }); err != nil {
22803                 if err == io.EOF {
22804                         chk(io.EOF)
22805                 }
22806                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LitFromBlks", err))
22807         }
22808         {
22809                 local281 := uint8(2) // Size of param0 in bytes.
22810                 {
22811                         x := local281
22812                         write8(w, uint8(x))
22813                 }
22814         }
22815         {
22816                 local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22817                 {
22818                         x := local282
22819                         write8(w, uint8(x))
22820                 }
22821         }
22822         {
22823                 w, err := zstd.NewWriter(w)
22824                 chk(err)
22825                 for local283 := range (*(*(struct {
22826                         Flags   MapBlkFlags
22827                         LitFrom LitFromBlks
22828
22829                         //mt:zstd
22830                         Param0 [4096]Content
22831                         Param1 [4096]uint8
22832                         Param2 [4096]uint8
22833
22834                         NodeMetas map[uint16]*NodeMeta
22835                 }))(obj)).Param0 {
22836                         if err := pcall(func() {
22837                                 (((*(*(struct {
22838                                         Flags   MapBlkFlags
22839                                         LitFrom LitFromBlks
22840
22841                                         //mt:zstd
22842                                         Param0 [4096]Content
22843                                         Param1 [4096]uint8
22844                                         Param2 [4096]uint8
22845
22846                                         NodeMetas map[uint16]*NodeMeta
22847                                 }))(obj)).Param0)[local283]).serialize(w)
22848                         }); err != nil {
22849                                 if err == io.EOF {
22850                                         chk(io.EOF)
22851                                 }
22852                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
22853                         }
22854                 }
22855                 {
22856                         _, err := w.Write(((*(*(struct {
22857                                 Flags   MapBlkFlags
22858                                 LitFrom LitFromBlks
22859
22860                                 //mt:zstd
22861                                 Param0 [4096]Content
22862                                 Param1 [4096]uint8
22863                                 Param2 [4096]uint8
22864
22865                                 NodeMetas map[uint16]*NodeMeta
22866                         }))(obj)).Param1)[:])
22867                         chk(err)
22868                 }
22869                 {
22870                         _, err := w.Write(((*(*(struct {
22871                                 Flags   MapBlkFlags
22872                                 LitFrom LitFromBlks
22873
22874                                 //mt:zstd
22875                                 Param0 [4096]Content
22876                                 Param1 [4096]uint8
22877                                 Param2 [4096]uint8
22878
22879                                 NodeMetas map[uint16]*NodeMeta
22880                         }))(obj)).Param2)[:])
22881                         chk(err)
22882                 }
22883                 chk(w.Close())
22884         }
22885         {
22886                 x := (*(*(struct {
22887                         Flags   MapBlkFlags
22888                         LitFrom LitFromBlks
22889
22890                         //mt:zstd
22891                         Param0 [4096]Content
22892                         Param1 [4096]uint8
22893                         Param2 [4096]uint8
22894
22895                         NodeMetas map[uint16]*NodeMeta
22896                 }))(obj)).NodeMetas
22897                 {
22898                         w := zlib.NewWriter(w)
22899
22900                         if x == nil {
22901                                 write8(w, 0)
22902                         } else {
22903                                 write8(w, 2)
22904                                 // len(map[uint16]...) always < math.MaxUint16
22905                                 write16(w, uint16(len(x)))
22906                                 keys := make([]uint16, 0, len(x))
22907                                 for key := range x {
22908                                         keys = append(keys, key)
22909                                 }
22910                                 sort.Slice(keys, func(i, j int) bool {
22911                                         i2pos := func(i int) [3]int16 {
22912                                                 return Blkpos2Pos([3]int16{}, keys[i])
22913                                         }
22914
22915                                         p, q := i2pos(i), i2pos(j)
22916
22917                                         for i := range p {
22918                                                 switch {
22919                                                 case p[i] < q[i]:
22920                                                         return true
22921                                                 case p[i] > q[i]:
22922                                                         return false
22923                                                 }
22924                                         }
22925
22926                                         return false
22927                                 })
22928                                 for _, key := range keys {
22929                                         write16(w, key)
22930                                         chk(serialize(w, x[key]))
22931                                 }
22932                         }
22933
22934                         chk(w.Close())
22935                 }
22936
22937         }
22938         {
22939                 local284 := uint8(2) // version
22940                 {
22941                         x := local284
22942                         write8(w, uint8(x))
22943                 }
22944         }
22945 }
22946
22947 func (obj *MapBlk) deserialize(r io.Reader) {
22948         if err := pcall(func() {
22949                 ((*(*(struct {
22950                         Flags   MapBlkFlags
22951                         LitFrom LitFromBlks
22952
22953                         //mt:zstd
22954                         Param0 [4096]Content
22955                         Param1 [4096]uint8
22956                         Param2 [4096]uint8
22957
22958                         NodeMetas map[uint16]*NodeMeta
22959                 }))(obj)).Flags).deserialize(r)
22960         }); err != nil {
22961                 if err == io.EOF {
22962                         chk(io.EOF)
22963                 }
22964                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.MapBlkFlags", err))
22965         }
22966         if err := pcall(func() {
22967                 ((*(*(struct {
22968                         Flags   MapBlkFlags
22969                         LitFrom LitFromBlks
22970
22971                         //mt:zstd
22972                         Param0 [4096]Content
22973                         Param1 [4096]uint8
22974                         Param2 [4096]uint8
22975
22976                         NodeMetas map[uint16]*NodeMeta
22977                 }))(obj)).LitFrom).deserialize(r)
22978         }); err != nil {
22979                 if err == io.EOF {
22980                         chk(io.EOF)
22981                 }
22982                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.LitFromBlks", err))
22983         }
22984         {
22985                 var local285 uint8
22986                 local286 := uint8(2) // Size of param0 in bytes.
22987                 {
22988                         p := &local285
22989                         *p = read8(r)
22990                 }
22991                 if local285 != local286 {
22992                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local285))
22993                 }
22994         }
22995         {
22996                 var local287 uint8
22997                 local288 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
22998                 {
22999                         p := &local287
23000                         *p = read8(r)
23001                 }
23002                 if local287 != local288 {
23003                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local287))
23004                 }
23005         }
23006         {
23007                 r, err := zstd.NewReader(byteReader{r})
23008                 chk(err)
23009                 for local289 := range (*(*(struct {
23010                         Flags   MapBlkFlags
23011                         LitFrom LitFromBlks
23012
23013                         //mt:zstd
23014                         Param0 [4096]Content
23015                         Param1 [4096]uint8
23016                         Param2 [4096]uint8
23017
23018                         NodeMetas map[uint16]*NodeMeta
23019                 }))(obj)).Param0 {
23020                         if err := pcall(func() {
23021                                 (((*(*(struct {
23022                                         Flags   MapBlkFlags
23023                                         LitFrom LitFromBlks
23024
23025                                         //mt:zstd
23026                                         Param0 [4096]Content
23027                                         Param1 [4096]uint8
23028                                         Param2 [4096]uint8
23029
23030                                         NodeMetas map[uint16]*NodeMeta
23031                                 }))(obj)).Param0)[local289]).deserialize(r)
23032                         }); err != nil {
23033                                 if err == io.EOF {
23034                                         chk(io.EOF)
23035                                 }
23036                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
23037                         }
23038                 }
23039                 {
23040                         _, err := io.ReadFull(r, ((*(*(struct {
23041                                 Flags   MapBlkFlags
23042                                 LitFrom LitFromBlks
23043
23044                                 //mt:zstd
23045                                 Param0 [4096]Content
23046                                 Param1 [4096]uint8
23047                                 Param2 [4096]uint8
23048
23049                                 NodeMetas map[uint16]*NodeMeta
23050                         }))(obj)).Param1)[:])
23051                         chk(err)
23052                 }
23053                 {
23054                         _, err := io.ReadFull(r, ((*(*(struct {
23055                                 Flags   MapBlkFlags
23056                                 LitFrom LitFromBlks
23057
23058                                 //mt:zstd
23059                                 Param0 [4096]Content
23060                                 Param1 [4096]uint8
23061                                 Param2 [4096]uint8
23062
23063                                 NodeMetas map[uint16]*NodeMeta
23064                         }))(obj)).Param2)[:])
23065                         chk(err)
23066                 }
23067                 r.Close()
23068         }
23069         {
23070                 p := &(*(*(struct {
23071                         Flags   MapBlkFlags
23072                         LitFrom LitFromBlks
23073
23074                         //mt:zstd
23075                         Param0 [4096]Content
23076                         Param1 [4096]uint8
23077                         Param2 [4096]uint8
23078
23079                         NodeMetas map[uint16]*NodeMeta
23080                 }))(obj)).NodeMetas
23081                 {
23082                         r, err := zlib.NewReader(byteReader{r})
23083                         chk(err)
23084
23085                         switch ver := read8(r); ver {
23086                         case 0:
23087                                 *p = nil
23088                         case 2:
23089                                 n := read16(r)
23090                                 *p = make(map[uint16]*NodeMeta, n)
23091                                 for ; n > 0; n-- {
23092                                         pos := read16(r)
23093                                         nm := new(NodeMeta)
23094                                         chk(deserialize(r, nm))
23095                                         (*p)[pos] = nm
23096                                 }
23097                         default:
23098                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
23099                         }
23100
23101                         chk(r.Close())
23102                 }
23103
23104         }
23105         {
23106                 var local290 uint8
23107                 local291 := uint8(2) // version
23108                 {
23109                         p := &local290
23110                         *p = read8(r)
23111                 }
23112                 if local290 != local291 {
23113                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local290))
23114                 }
23115         }
23116 }
23117
23118 func (obj *Node) serialize(w io.Writer) {
23119         if err := pcall(func() {
23120                 ((*(*(struct {
23121                         Param0         Content
23122                         Param1, Param2 uint8
23123                 }))(obj)).Param0).serialize(w)
23124         }); err != nil {
23125                 if err == io.EOF {
23126                         chk(io.EOF)
23127                 }
23128                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
23129         }
23130         {
23131                 x := (*(*(struct {
23132                         Param0         Content
23133                         Param1, Param2 uint8
23134                 }))(obj)).Param1
23135                 write8(w, uint8(x))
23136         }
23137         {
23138                 x := (*(*(struct {
23139                         Param0         Content
23140                         Param1, Param2 uint8
23141                 }))(obj)).Param2
23142                 write8(w, uint8(x))
23143         }
23144 }
23145
23146 func (obj *Node) deserialize(r io.Reader) {
23147         if err := pcall(func() {
23148                 ((*(*(struct {
23149                         Param0         Content
23150                         Param1, Param2 uint8
23151                 }))(obj)).Param0).deserialize(r)
23152         }); err != nil {
23153                 if err == io.EOF {
23154                         chk(io.EOF)
23155                 }
23156                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Content", err))
23157         }
23158         {
23159                 p := &(*(*(struct {
23160                         Param0         Content
23161                         Param1, Param2 uint8
23162                 }))(obj)).Param1
23163                 *p = read8(r)
23164         }
23165         {
23166                 p := &(*(*(struct {
23167                         Param0         Content
23168                         Param1, Param2 uint8
23169                 }))(obj)).Param2
23170                 *p = read8(r)
23171         }
23172 }
23173
23174 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
23175         {
23176                 x := *(*(uint64))(obj)
23177                 write64(w, uint64(x))
23178
23179         }
23180 }
23181
23182 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
23183         {
23184                 p := &*(*(uint64))(obj)
23185                 *p = read64(r)
23186
23187         }
23188 }
23189
23190 func (obj *Vec) serialize(w io.Writer) {
23191         for local292 := range *(*([3]float32))(obj) {
23192                 {
23193                         x := (*(*([3]float32))(obj))[local292]
23194                         write32(w, math.Float32bits(x))
23195                 }
23196         }
23197 }
23198
23199 func (obj *Vec) deserialize(r io.Reader) {
23200         for local293 := range *(*([3]float32))(obj) {
23201                 {
23202                         p := &(*(*([3]float32))(obj))[local293]
23203                         *p = math.Float32frombits(read32(r))
23204                 }
23205         }
23206 }
23207
23208 func (obj *ChatMsgType) serialize(w io.Writer) {
23209         {
23210                 x := *(*(uint8))(obj)
23211                 write8(w, uint8(x))
23212         }
23213 }
23214
23215 func (obj *ChatMsgType) deserialize(r io.Reader) {
23216         {
23217                 p := &*(*(uint8))(obj)
23218                 *p = read8(r)
23219         }
23220 }
23221
23222 func (obj *AOID) serialize(w io.Writer) {
23223         {
23224                 x := *(*(uint16))(obj)
23225                 write16(w, uint16(x))
23226         }
23227 }
23228
23229 func (obj *AOID) deserialize(r io.Reader) {
23230         {
23231                 p := &*(*(uint16))(obj)
23232                 *p = read16(r)
23233         }
23234 }
23235
23236 func (obj *AOAdd) serialize(w io.Writer) {
23237         if err := pcall(func() {
23238                 ((*(*(struct {
23239                         ID AOID
23240                         //mt:const genericCAO
23241                         //mt:lenhdr 32
23242                         InitData AOInitData
23243                 }))(obj)).ID).serialize(w)
23244         }); err != nil {
23245                 if err == io.EOF {
23246                         chk(io.EOF)
23247                 }
23248                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23249         }
23250         {
23251                 local294 := genericCAO
23252                 if err := pcall(func() {
23253                         (local294).serialize(w)
23254                 }); err != nil {
23255                         if err == io.EOF {
23256                                 chk(io.EOF)
23257                         }
23258                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
23259                 }
23260         }
23261         {
23262                 ow := w
23263                 w := new(bytes.Buffer)
23264                 if err := pcall(func() {
23265                         ((*(*(struct {
23266                                 ID AOID
23267                                 //mt:const genericCAO
23268                                 //mt:lenhdr 32
23269                                 InitData AOInitData
23270                         }))(obj)).InitData).serialize(w)
23271                 }); err != nil {
23272                         if err == io.EOF {
23273                                 chk(io.EOF)
23274                         }
23275                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOInitData", err))
23276                 }
23277                 {
23278                         buf := w
23279                         w := ow
23280                         if len((buf.Bytes())) > math.MaxUint32 {
23281                                 chk(ErrTooLong)
23282                         }
23283                         {
23284                                 x := uint32(len((buf.Bytes())))
23285                                 write32(w, uint32(x))
23286                         }
23287                         {
23288                                 _, err := w.Write((buf.Bytes())[:])
23289                                 chk(err)
23290                         }
23291                 }
23292         }
23293 }
23294
23295 func (obj *AOAdd) deserialize(r io.Reader) {
23296         if err := pcall(func() {
23297                 ((*(*(struct {
23298                         ID AOID
23299                         //mt:const genericCAO
23300                         //mt:lenhdr 32
23301                         InitData AOInitData
23302                 }))(obj)).ID).deserialize(r)
23303         }); err != nil {
23304                 if err == io.EOF {
23305                         chk(io.EOF)
23306                 }
23307                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23308         }
23309         {
23310                 var local295 aoType
23311                 local296 := genericCAO
23312                 if err := pcall(func() {
23313                         (local295).deserialize(r)
23314                 }); err != nil {
23315                         if err == io.EOF {
23316                                 chk(io.EOF)
23317                         }
23318                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.aoType", err))
23319                 }
23320                 if local295 != local296 {
23321                         chk(fmt.Errorf("const %v: %v", "genericCAO", local295))
23322                 }
23323         }
23324         {
23325                 var n uint32
23326                 {
23327                         p := &n
23328                         *p = read32(r)
23329                 }
23330                 r := &io.LimitedReader{R: r, N: int64(n)}
23331                 if err := pcall(func() {
23332                         ((*(*(struct {
23333                                 ID AOID
23334                                 //mt:const genericCAO
23335                                 //mt:lenhdr 32
23336                                 InitData AOInitData
23337                         }))(obj)).InitData).deserialize(r)
23338                 }); err != nil {
23339                         if err == io.EOF {
23340                                 chk(io.EOF)
23341                         }
23342                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOInitData", err))
23343                 }
23344                 if r.N > 0 {
23345                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23346                 }
23347         }
23348 }
23349
23350 func (obj *IDAOMsg) serialize(w io.Writer) {
23351         if err := pcall(func() {
23352                 ((*(*(struct {
23353                         ID AOID
23354                         //mt:lenhdr 16
23355                         Msg AOMsg
23356                 }))(obj)).ID).serialize(w)
23357         }); err != nil {
23358                 if err == io.EOF {
23359                         chk(io.EOF)
23360                 }
23361                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23362         }
23363         {
23364                 ow := w
23365                 w := new(bytes.Buffer)
23366                 {
23367                         x := (*(*(struct {
23368                                 ID AOID
23369                                 //mt:lenhdr 16
23370                                 Msg AOMsg
23371                         }))(obj)).Msg
23372                         writeAOMsg(w, x)
23373
23374                 }
23375                 {
23376                         buf := w
23377                         w := ow
23378                         if len((buf.Bytes())) > math.MaxUint16 {
23379                                 chk(ErrTooLong)
23380                         }
23381                         {
23382                                 x := uint16(len((buf.Bytes())))
23383                                 write16(w, uint16(x))
23384                         }
23385                         {
23386                                 _, err := w.Write((buf.Bytes())[:])
23387                                 chk(err)
23388                         }
23389                 }
23390         }
23391 }
23392
23393 func (obj *IDAOMsg) deserialize(r io.Reader) {
23394         if err := pcall(func() {
23395                 ((*(*(struct {
23396                         ID AOID
23397                         //mt:lenhdr 16
23398                         Msg AOMsg
23399                 }))(obj)).ID).deserialize(r)
23400         }); err != nil {
23401                 if err == io.EOF {
23402                         chk(io.EOF)
23403                 }
23404                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
23405         }
23406         {
23407                 var n uint16
23408                 {
23409                         p := &n
23410                         *p = read16(r)
23411                 }
23412                 r := &io.LimitedReader{R: r, N: int64(n)}
23413                 {
23414                         p := &(*(*(struct {
23415                                 ID AOID
23416                                 //mt:lenhdr 16
23417                                 Msg AOMsg
23418                         }))(obj)).Msg
23419                         {
23420                                 var err error
23421                                 *p, err = readAOMsg(r)
23422                                 chk(err)
23423                         }
23424
23425                 }
23426                 if r.N > 0 {
23427                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23428                 }
23429         }
23430 }
23431
23432 func (obj *ItemDef) serialize(w io.Writer) {
23433         {
23434                 ow := w
23435                 w := new(bytes.Buffer)
23436                 {
23437                         local297 := uint8(6)
23438                         {
23439                                 x := local297
23440                                 write8(w, uint8(x))
23441                         }
23442                 }
23443                 if err := pcall(func() {
23444                         ((*(*(struct {
23445                                 Type ItemType
23446
23447                                 Name, Desc string
23448
23449                                 InvImg, WieldImg Texture
23450                                 WieldScale       [3]float32
23451
23452                                 StackMax uint16
23453
23454                                 Usable          bool
23455                                 CanPointLiquids bool
23456
23457                                 ToolCaps ToolCaps
23458
23459                                 Groups []Group
23460
23461                                 PlacePredict string
23462
23463                                 PlaceSnd, PlaceFailSnd SoundDef
23464
23465                                 PointRange float32
23466
23467                                 // Set index in Palette with "palette_index" item meta field,
23468                                 // this overrides Color.
23469                                 Palette Texture
23470                                 Color   color.NRGBA
23471
23472                                 // Texture overlays.
23473                                 InvOverlay, WieldOverlay Texture
23474
23475                                 ShortDesc string
23476                         }))(obj)).Type).serialize(w)
23477                 }); err != nil {
23478                         if err == io.EOF {
23479                                 chk(io.EOF)
23480                         }
23481                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemType", err))
23482                 }
23483                 if len(([]byte((*(*(struct {
23484                         Type ItemType
23485
23486                         Name, Desc string
23487
23488                         InvImg, WieldImg Texture
23489                         WieldScale       [3]float32
23490
23491                         StackMax uint16
23492
23493                         Usable          bool
23494                         CanPointLiquids bool
23495
23496                         ToolCaps ToolCaps
23497
23498                         Groups []Group
23499
23500                         PlacePredict string
23501
23502                         PlaceSnd, PlaceFailSnd SoundDef
23503
23504                         PointRange float32
23505
23506                         // Set index in Palette with "palette_index" item meta field,
23507                         // this overrides Color.
23508                         Palette Texture
23509                         Color   color.NRGBA
23510
23511                         // Texture overlays.
23512                         InvOverlay, WieldOverlay Texture
23513
23514                         ShortDesc string
23515                 }))(obj)).Name))) > math.MaxUint16 {
23516                         chk(ErrTooLong)
23517                 }
23518                 {
23519                         x := uint16(len(([]byte((*(*(struct {
23520                                 Type ItemType
23521
23522                                 Name, Desc string
23523
23524                                 InvImg, WieldImg Texture
23525                                 WieldScale       [3]float32
23526
23527                                 StackMax uint16
23528
23529                                 Usable          bool
23530                                 CanPointLiquids bool
23531
23532                                 ToolCaps ToolCaps
23533
23534                                 Groups []Group
23535
23536                                 PlacePredict string
23537
23538                                 PlaceSnd, PlaceFailSnd SoundDef
23539
23540                                 PointRange float32
23541
23542                                 // Set index in Palette with "palette_index" item meta field,
23543                                 // this overrides Color.
23544                                 Palette Texture
23545                                 Color   color.NRGBA
23546
23547                                 // Texture overlays.
23548                                 InvOverlay, WieldOverlay Texture
23549
23550                                 ShortDesc string
23551                         }))(obj)).Name))))
23552                         write16(w, uint16(x))
23553                 }
23554                 {
23555                         _, err := w.Write(([]byte((*(*(struct {
23556                                 Type ItemType
23557
23558                                 Name, Desc string
23559
23560                                 InvImg, WieldImg Texture
23561                                 WieldScale       [3]float32
23562
23563                                 StackMax uint16
23564
23565                                 Usable          bool
23566                                 CanPointLiquids bool
23567
23568                                 ToolCaps ToolCaps
23569
23570                                 Groups []Group
23571
23572                                 PlacePredict string
23573
23574                                 PlaceSnd, PlaceFailSnd SoundDef
23575
23576                                 PointRange float32
23577
23578                                 // Set index in Palette with "palette_index" item meta field,
23579                                 // this overrides Color.
23580                                 Palette Texture
23581                                 Color   color.NRGBA
23582
23583                                 // Texture overlays.
23584                                 InvOverlay, WieldOverlay Texture
23585
23586                                 ShortDesc string
23587                         }))(obj)).Name))[:])
23588                         chk(err)
23589                 }
23590                 if len(([]byte((*(*(struct {
23591                         Type ItemType
23592
23593                         Name, Desc string
23594
23595                         InvImg, WieldImg Texture
23596                         WieldScale       [3]float32
23597
23598                         StackMax uint16
23599
23600                         Usable          bool
23601                         CanPointLiquids bool
23602
23603                         ToolCaps ToolCaps
23604
23605                         Groups []Group
23606
23607                         PlacePredict string
23608
23609                         PlaceSnd, PlaceFailSnd SoundDef
23610
23611                         PointRange float32
23612
23613                         // Set index in Palette with "palette_index" item meta field,
23614                         // this overrides Color.
23615                         Palette Texture
23616                         Color   color.NRGBA
23617
23618                         // Texture overlays.
23619                         InvOverlay, WieldOverlay Texture
23620
23621                         ShortDesc string
23622                 }))(obj)).Desc))) > math.MaxUint16 {
23623                         chk(ErrTooLong)
23624                 }
23625                 {
23626                         x := uint16(len(([]byte((*(*(struct {
23627                                 Type ItemType
23628
23629                                 Name, Desc string
23630
23631                                 InvImg, WieldImg Texture
23632                                 WieldScale       [3]float32
23633
23634                                 StackMax uint16
23635
23636                                 Usable          bool
23637                                 CanPointLiquids bool
23638
23639                                 ToolCaps ToolCaps
23640
23641                                 Groups []Group
23642
23643                                 PlacePredict string
23644
23645                                 PlaceSnd, PlaceFailSnd SoundDef
23646
23647                                 PointRange float32
23648
23649                                 // Set index in Palette with "palette_index" item meta field,
23650                                 // this overrides Color.
23651                                 Palette Texture
23652                                 Color   color.NRGBA
23653
23654                                 // Texture overlays.
23655                                 InvOverlay, WieldOverlay Texture
23656
23657                                 ShortDesc string
23658                         }))(obj)).Desc))))
23659                         write16(w, uint16(x))
23660                 }
23661                 {
23662                         _, err := w.Write(([]byte((*(*(struct {
23663                                 Type ItemType
23664
23665                                 Name, Desc string
23666
23667                                 InvImg, WieldImg Texture
23668                                 WieldScale       [3]float32
23669
23670                                 StackMax uint16
23671
23672                                 Usable          bool
23673                                 CanPointLiquids bool
23674
23675                                 ToolCaps ToolCaps
23676
23677                                 Groups []Group
23678
23679                                 PlacePredict string
23680
23681                                 PlaceSnd, PlaceFailSnd SoundDef
23682
23683                                 PointRange float32
23684
23685                                 // Set index in Palette with "palette_index" item meta field,
23686                                 // this overrides Color.
23687                                 Palette Texture
23688                                 Color   color.NRGBA
23689
23690                                 // Texture overlays.
23691                                 InvOverlay, WieldOverlay Texture
23692
23693                                 ShortDesc string
23694                         }))(obj)).Desc))[:])
23695                         chk(err)
23696                 }
23697                 if err := pcall(func() {
23698                         ((*(*(struct {
23699                                 Type ItemType
23700
23701                                 Name, Desc string
23702
23703                                 InvImg, WieldImg Texture
23704                                 WieldScale       [3]float32
23705
23706                                 StackMax uint16
23707
23708                                 Usable          bool
23709                                 CanPointLiquids bool
23710
23711                                 ToolCaps ToolCaps
23712
23713                                 Groups []Group
23714
23715                                 PlacePredict string
23716
23717                                 PlaceSnd, PlaceFailSnd SoundDef
23718
23719                                 PointRange float32
23720
23721                                 // Set index in Palette with "palette_index" item meta field,
23722                                 // this overrides Color.
23723                                 Palette Texture
23724                                 Color   color.NRGBA
23725
23726                                 // Texture overlays.
23727                                 InvOverlay, WieldOverlay Texture
23728
23729                                 ShortDesc string
23730                         }))(obj)).InvImg).serialize(w)
23731                 }); err != nil {
23732                         if err == io.EOF {
23733                                 chk(io.EOF)
23734                         }
23735                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
23736                 }
23737                 if err := pcall(func() {
23738                         ((*(*(struct {
23739                                 Type ItemType
23740
23741                                 Name, Desc string
23742
23743                                 InvImg, WieldImg Texture
23744                                 WieldScale       [3]float32
23745
23746                                 StackMax uint16
23747
23748                                 Usable          bool
23749                                 CanPointLiquids bool
23750
23751                                 ToolCaps ToolCaps
23752
23753                                 Groups []Group
23754
23755                                 PlacePredict string
23756
23757                                 PlaceSnd, PlaceFailSnd SoundDef
23758
23759                                 PointRange float32
23760
23761                                 // Set index in Palette with "palette_index" item meta field,
23762                                 // this overrides Color.
23763                                 Palette Texture
23764                                 Color   color.NRGBA
23765
23766                                 // Texture overlays.
23767                                 InvOverlay, WieldOverlay Texture
23768
23769                                 ShortDesc string
23770                         }))(obj)).WieldImg).serialize(w)
23771                 }); err != nil {
23772                         if err == io.EOF {
23773                                 chk(io.EOF)
23774                         }
23775                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
23776                 }
23777                 for local298 := range (*(*(struct {
23778                         Type ItemType
23779
23780                         Name, Desc string
23781
23782                         InvImg, WieldImg Texture
23783                         WieldScale       [3]float32
23784
23785                         StackMax uint16
23786
23787                         Usable          bool
23788                         CanPointLiquids bool
23789
23790                         ToolCaps ToolCaps
23791
23792                         Groups []Group
23793
23794                         PlacePredict string
23795
23796                         PlaceSnd, PlaceFailSnd SoundDef
23797
23798                         PointRange float32
23799
23800                         // Set index in Palette with "palette_index" item meta field,
23801                         // this overrides Color.
23802                         Palette Texture
23803                         Color   color.NRGBA
23804
23805                         // Texture overlays.
23806                         InvOverlay, WieldOverlay Texture
23807
23808                         ShortDesc string
23809                 }))(obj)).WieldScale {
23810                         {
23811                                 x := ((*(*(struct {
23812                                         Type ItemType
23813
23814                                         Name, Desc string
23815
23816                                         InvImg, WieldImg Texture
23817                                         WieldScale       [3]float32
23818
23819                                         StackMax uint16
23820
23821                                         Usable          bool
23822                                         CanPointLiquids bool
23823
23824                                         ToolCaps ToolCaps
23825
23826                                         Groups []Group
23827
23828                                         PlacePredict string
23829
23830                                         PlaceSnd, PlaceFailSnd SoundDef
23831
23832                                         PointRange float32
23833
23834                                         // Set index in Palette with "palette_index" item meta field,
23835                                         // this overrides Color.
23836                                         Palette Texture
23837                                         Color   color.NRGBA
23838
23839                                         // Texture overlays.
23840                                         InvOverlay, WieldOverlay Texture
23841
23842                                         ShortDesc string
23843                                 }))(obj)).WieldScale)[local298]
23844                                 write32(w, math.Float32bits(x))
23845                         }
23846                 }
23847                 {
23848                         x := (*(*(struct {
23849                                 Type ItemType
23850
23851                                 Name, Desc string
23852
23853                                 InvImg, WieldImg Texture
23854                                 WieldScale       [3]float32
23855
23856                                 StackMax uint16
23857
23858                                 Usable          bool
23859                                 CanPointLiquids bool
23860
23861                                 ToolCaps ToolCaps
23862
23863                                 Groups []Group
23864
23865                                 PlacePredict string
23866
23867                                 PlaceSnd, PlaceFailSnd SoundDef
23868
23869                                 PointRange float32
23870
23871                                 // Set index in Palette with "palette_index" item meta field,
23872                                 // this overrides Color.
23873                                 Palette Texture
23874                                 Color   color.NRGBA
23875
23876                                 // Texture overlays.
23877                                 InvOverlay, WieldOverlay Texture
23878
23879                                 ShortDesc string
23880                         }))(obj)).StackMax
23881                         write16(w, uint16(x))
23882                 }
23883                 {
23884                         x := (*(*(struct {
23885                                 Type ItemType
23886
23887                                 Name, Desc string
23888
23889                                 InvImg, WieldImg Texture
23890                                 WieldScale       [3]float32
23891
23892                                 StackMax uint16
23893
23894                                 Usable          bool
23895                                 CanPointLiquids bool
23896
23897                                 ToolCaps ToolCaps
23898
23899                                 Groups []Group
23900
23901                                 PlacePredict string
23902
23903                                 PlaceSnd, PlaceFailSnd SoundDef
23904
23905                                 PointRange float32
23906
23907                                 // Set index in Palette with "palette_index" item meta field,
23908                                 // this overrides Color.
23909                                 Palette Texture
23910                                 Color   color.NRGBA
23911
23912                                 // Texture overlays.
23913                                 InvOverlay, WieldOverlay Texture
23914
23915                                 ShortDesc string
23916                         }))(obj)).Usable
23917                         if x {
23918                                 write8(w, 1)
23919                         } else {
23920                                 write8(w, 0)
23921                         }
23922
23923                 }
23924                 {
23925                         x := (*(*(struct {
23926                                 Type ItemType
23927
23928                                 Name, Desc string
23929
23930                                 InvImg, WieldImg Texture
23931                                 WieldScale       [3]float32
23932
23933                                 StackMax uint16
23934
23935                                 Usable          bool
23936                                 CanPointLiquids bool
23937
23938                                 ToolCaps ToolCaps
23939
23940                                 Groups []Group
23941
23942                                 PlacePredict string
23943
23944                                 PlaceSnd, PlaceFailSnd SoundDef
23945
23946                                 PointRange float32
23947
23948                                 // Set index in Palette with "palette_index" item meta field,
23949                                 // this overrides Color.
23950                                 Palette Texture
23951                                 Color   color.NRGBA
23952
23953                                 // Texture overlays.
23954                                 InvOverlay, WieldOverlay Texture
23955
23956                                 ShortDesc string
23957                         }))(obj)).CanPointLiquids
23958                         if x {
23959                                 write8(w, 1)
23960                         } else {
23961                                 write8(w, 0)
23962                         }
23963
23964                 }
23965                 if err := pcall(func() {
23966                         ((*(*(struct {
23967                                 Type ItemType
23968
23969                                 Name, Desc string
23970
23971                                 InvImg, WieldImg Texture
23972                                 WieldScale       [3]float32
23973
23974                                 StackMax uint16
23975
23976                                 Usable          bool
23977                                 CanPointLiquids bool
23978
23979                                 ToolCaps ToolCaps
23980
23981                                 Groups []Group
23982
23983                                 PlacePredict string
23984
23985                                 PlaceSnd, PlaceFailSnd SoundDef
23986
23987                                 PointRange float32
23988
23989                                 // Set index in Palette with "palette_index" item meta field,
23990                                 // this overrides Color.
23991                                 Palette Texture
23992                                 Color   color.NRGBA
23993
23994                                 // Texture overlays.
23995                                 InvOverlay, WieldOverlay Texture
23996
23997                                 ShortDesc string
23998                         }))(obj)).ToolCaps).serialize(w)
23999                 }); err != nil {
24000                         if err == io.EOF {
24001                                 chk(io.EOF)
24002                         }
24003                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolCaps", err))
24004                 }
24005                 if len(((*(*(struct {
24006                         Type ItemType
24007
24008                         Name, Desc string
24009
24010                         InvImg, WieldImg Texture
24011                         WieldScale       [3]float32
24012
24013                         StackMax uint16
24014
24015                         Usable          bool
24016                         CanPointLiquids bool
24017
24018                         ToolCaps ToolCaps
24019
24020                         Groups []Group
24021
24022                         PlacePredict string
24023
24024                         PlaceSnd, PlaceFailSnd SoundDef
24025
24026                         PointRange float32
24027
24028                         // Set index in Palette with "palette_index" item meta field,
24029                         // this overrides Color.
24030                         Palette Texture
24031                         Color   color.NRGBA
24032
24033                         // Texture overlays.
24034                         InvOverlay, WieldOverlay Texture
24035
24036                         ShortDesc string
24037                 }))(obj)).Groups)) > math.MaxUint16 {
24038                         chk(ErrTooLong)
24039                 }
24040                 {
24041                         x := uint16(len(((*(*(struct {
24042                                 Type ItemType
24043
24044                                 Name, Desc string
24045
24046                                 InvImg, WieldImg Texture
24047                                 WieldScale       [3]float32
24048
24049                                 StackMax uint16
24050
24051                                 Usable          bool
24052                                 CanPointLiquids bool
24053
24054                                 ToolCaps ToolCaps
24055
24056                                 Groups []Group
24057
24058                                 PlacePredict string
24059
24060                                 PlaceSnd, PlaceFailSnd SoundDef
24061
24062                                 PointRange float32
24063
24064                                 // Set index in Palette with "palette_index" item meta field,
24065                                 // this overrides Color.
24066                                 Palette Texture
24067                                 Color   color.NRGBA
24068
24069                                 // Texture overlays.
24070                                 InvOverlay, WieldOverlay Texture
24071
24072                                 ShortDesc string
24073                         }))(obj)).Groups)))
24074                         write16(w, uint16(x))
24075                 }
24076                 for local299 := range (*(*(struct {
24077                         Type ItemType
24078
24079                         Name, Desc string
24080
24081                         InvImg, WieldImg Texture
24082                         WieldScale       [3]float32
24083
24084                         StackMax uint16
24085
24086                         Usable          bool
24087                         CanPointLiquids bool
24088
24089                         ToolCaps ToolCaps
24090
24091                         Groups []Group
24092
24093                         PlacePredict string
24094
24095                         PlaceSnd, PlaceFailSnd SoundDef
24096
24097                         PointRange float32
24098
24099                         // Set index in Palette with "palette_index" item meta field,
24100                         // this overrides Color.
24101                         Palette Texture
24102                         Color   color.NRGBA
24103
24104                         // Texture overlays.
24105                         InvOverlay, WieldOverlay Texture
24106
24107                         ShortDesc string
24108                 }))(obj)).Groups {
24109                         if err := pcall(func() {
24110                                 (((*(*(struct {
24111                                         Type ItemType
24112
24113                                         Name, Desc string
24114
24115                                         InvImg, WieldImg Texture
24116                                         WieldScale       [3]float32
24117
24118                                         StackMax uint16
24119
24120                                         Usable          bool
24121                                         CanPointLiquids bool
24122
24123                                         ToolCaps ToolCaps
24124
24125                                         Groups []Group
24126
24127                                         PlacePredict string
24128
24129                                         PlaceSnd, PlaceFailSnd SoundDef
24130
24131                                         PointRange float32
24132
24133                                         // Set index in Palette with "palette_index" item meta field,
24134                                         // this overrides Color.
24135                                         Palette Texture
24136                                         Color   color.NRGBA
24137
24138                                         // Texture overlays.
24139                                         InvOverlay, WieldOverlay Texture
24140
24141                                         ShortDesc string
24142                                 }))(obj)).Groups)[local299]).serialize(w)
24143                         }); err != nil {
24144                                 if err == io.EOF {
24145                                         chk(io.EOF)
24146                                 }
24147                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
24148                         }
24149                 }
24150                 if len(([]byte((*(*(struct {
24151                         Type ItemType
24152
24153                         Name, Desc string
24154
24155                         InvImg, WieldImg Texture
24156                         WieldScale       [3]float32
24157
24158                         StackMax uint16
24159
24160                         Usable          bool
24161                         CanPointLiquids bool
24162
24163                         ToolCaps ToolCaps
24164
24165                         Groups []Group
24166
24167                         PlacePredict string
24168
24169                         PlaceSnd, PlaceFailSnd SoundDef
24170
24171                         PointRange float32
24172
24173                         // Set index in Palette with "palette_index" item meta field,
24174                         // this overrides Color.
24175                         Palette Texture
24176                         Color   color.NRGBA
24177
24178                         // Texture overlays.
24179                         InvOverlay, WieldOverlay Texture
24180
24181                         ShortDesc string
24182                 }))(obj)).PlacePredict))) > math.MaxUint16 {
24183                         chk(ErrTooLong)
24184                 }
24185                 {
24186                         x := uint16(len(([]byte((*(*(struct {
24187                                 Type ItemType
24188
24189                                 Name, Desc string
24190
24191                                 InvImg, WieldImg Texture
24192                                 WieldScale       [3]float32
24193
24194                                 StackMax uint16
24195
24196                                 Usable          bool
24197                                 CanPointLiquids bool
24198
24199                                 ToolCaps ToolCaps
24200
24201                                 Groups []Group
24202
24203                                 PlacePredict string
24204
24205                                 PlaceSnd, PlaceFailSnd SoundDef
24206
24207                                 PointRange float32
24208
24209                                 // Set index in Palette with "palette_index" item meta field,
24210                                 // this overrides Color.
24211                                 Palette Texture
24212                                 Color   color.NRGBA
24213
24214                                 // Texture overlays.
24215                                 InvOverlay, WieldOverlay Texture
24216
24217                                 ShortDesc string
24218                         }))(obj)).PlacePredict))))
24219                         write16(w, uint16(x))
24220                 }
24221                 {
24222                         _, err := w.Write(([]byte((*(*(struct {
24223                                 Type ItemType
24224
24225                                 Name, Desc string
24226
24227                                 InvImg, WieldImg Texture
24228                                 WieldScale       [3]float32
24229
24230                                 StackMax uint16
24231
24232                                 Usable          bool
24233                                 CanPointLiquids bool
24234
24235                                 ToolCaps ToolCaps
24236
24237                                 Groups []Group
24238
24239                                 PlacePredict string
24240
24241                                 PlaceSnd, PlaceFailSnd SoundDef
24242
24243                                 PointRange float32
24244
24245                                 // Set index in Palette with "palette_index" item meta field,
24246                                 // this overrides Color.
24247                                 Palette Texture
24248                                 Color   color.NRGBA
24249
24250                                 // Texture overlays.
24251                                 InvOverlay, WieldOverlay Texture
24252
24253                                 ShortDesc string
24254                         }))(obj)).PlacePredict))[:])
24255                         chk(err)
24256                 }
24257                 if err := pcall(func() {
24258                         ((*(*(struct {
24259                                 Type ItemType
24260
24261                                 Name, Desc string
24262
24263                                 InvImg, WieldImg Texture
24264                                 WieldScale       [3]float32
24265
24266                                 StackMax uint16
24267
24268                                 Usable          bool
24269                                 CanPointLiquids bool
24270
24271                                 ToolCaps ToolCaps
24272
24273                                 Groups []Group
24274
24275                                 PlacePredict string
24276
24277                                 PlaceSnd, PlaceFailSnd SoundDef
24278
24279                                 PointRange float32
24280
24281                                 // Set index in Palette with "palette_index" item meta field,
24282                                 // this overrides Color.
24283                                 Palette Texture
24284                                 Color   color.NRGBA
24285
24286                                 // Texture overlays.
24287                                 InvOverlay, WieldOverlay Texture
24288
24289                                 ShortDesc string
24290                         }))(obj)).PlaceSnd).serialize(w)
24291                 }); err != nil {
24292                         if err == io.EOF {
24293                                 chk(io.EOF)
24294                         }
24295                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
24296                 }
24297                 if err := pcall(func() {
24298                         ((*(*(struct {
24299                                 Type ItemType
24300
24301                                 Name, Desc string
24302
24303                                 InvImg, WieldImg Texture
24304                                 WieldScale       [3]float32
24305
24306                                 StackMax uint16
24307
24308                                 Usable          bool
24309                                 CanPointLiquids bool
24310
24311                                 ToolCaps ToolCaps
24312
24313                                 Groups []Group
24314
24315                                 PlacePredict string
24316
24317                                 PlaceSnd, PlaceFailSnd SoundDef
24318
24319                                 PointRange float32
24320
24321                                 // Set index in Palette with "palette_index" item meta field,
24322                                 // this overrides Color.
24323                                 Palette Texture
24324                                 Color   color.NRGBA
24325
24326                                 // Texture overlays.
24327                                 InvOverlay, WieldOverlay Texture
24328
24329                                 ShortDesc string
24330                         }))(obj)).PlaceFailSnd).serialize(w)
24331                 }); err != nil {
24332                         if err == io.EOF {
24333                                 chk(io.EOF)
24334                         }
24335                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
24336                 }
24337                 {
24338                         x := (*(*(struct {
24339                                 Type ItemType
24340
24341                                 Name, Desc string
24342
24343                                 InvImg, WieldImg Texture
24344                                 WieldScale       [3]float32
24345
24346                                 StackMax uint16
24347
24348                                 Usable          bool
24349                                 CanPointLiquids bool
24350
24351                                 ToolCaps ToolCaps
24352
24353                                 Groups []Group
24354
24355                                 PlacePredict string
24356
24357                                 PlaceSnd, PlaceFailSnd SoundDef
24358
24359                                 PointRange float32
24360
24361                                 // Set index in Palette with "palette_index" item meta field,
24362                                 // this overrides Color.
24363                                 Palette Texture
24364                                 Color   color.NRGBA
24365
24366                                 // Texture overlays.
24367                                 InvOverlay, WieldOverlay Texture
24368
24369                                 ShortDesc string
24370                         }))(obj)).PointRange
24371                         write32(w, math.Float32bits(x))
24372                 }
24373                 if err := pcall(func() {
24374                         ((*(*(struct {
24375                                 Type ItemType
24376
24377                                 Name, Desc string
24378
24379                                 InvImg, WieldImg Texture
24380                                 WieldScale       [3]float32
24381
24382                                 StackMax uint16
24383
24384                                 Usable          bool
24385                                 CanPointLiquids bool
24386
24387                                 ToolCaps ToolCaps
24388
24389                                 Groups []Group
24390
24391                                 PlacePredict string
24392
24393                                 PlaceSnd, PlaceFailSnd SoundDef
24394
24395                                 PointRange float32
24396
24397                                 // Set index in Palette with "palette_index" item meta field,
24398                                 // this overrides Color.
24399                                 Palette Texture
24400                                 Color   color.NRGBA
24401
24402                                 // Texture overlays.
24403                                 InvOverlay, WieldOverlay Texture
24404
24405                                 ShortDesc string
24406                         }))(obj)).Palette).serialize(w)
24407                 }); err != nil {
24408                         if err == io.EOF {
24409                                 chk(io.EOF)
24410                         }
24411                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24412                 }
24413                 {
24414                         x := (*(*(struct {
24415                                 Type ItemType
24416
24417                                 Name, Desc string
24418
24419                                 InvImg, WieldImg Texture
24420                                 WieldScale       [3]float32
24421
24422                                 StackMax uint16
24423
24424                                 Usable          bool
24425                                 CanPointLiquids bool
24426
24427                                 ToolCaps ToolCaps
24428
24429                                 Groups []Group
24430
24431                                 PlacePredict string
24432
24433                                 PlaceSnd, PlaceFailSnd SoundDef
24434
24435                                 PointRange float32
24436
24437                                 // Set index in Palette with "palette_index" item meta field,
24438                                 // this overrides Color.
24439                                 Palette Texture
24440                                 Color   color.NRGBA
24441
24442                                 // Texture overlays.
24443                                 InvOverlay, WieldOverlay Texture
24444
24445                                 ShortDesc string
24446                         }))(obj)).Color
24447                         w.Write([]byte{x.A, x.R, x.G, x.B})
24448
24449                 }
24450                 if err := pcall(func() {
24451                         ((*(*(struct {
24452                                 Type ItemType
24453
24454                                 Name, Desc string
24455
24456                                 InvImg, WieldImg Texture
24457                                 WieldScale       [3]float32
24458
24459                                 StackMax uint16
24460
24461                                 Usable          bool
24462                                 CanPointLiquids bool
24463
24464                                 ToolCaps ToolCaps
24465
24466                                 Groups []Group
24467
24468                                 PlacePredict string
24469
24470                                 PlaceSnd, PlaceFailSnd SoundDef
24471
24472                                 PointRange float32
24473
24474                                 // Set index in Palette with "palette_index" item meta field,
24475                                 // this overrides Color.
24476                                 Palette Texture
24477                                 Color   color.NRGBA
24478
24479                                 // Texture overlays.
24480                                 InvOverlay, WieldOverlay Texture
24481
24482                                 ShortDesc string
24483                         }))(obj)).InvOverlay).serialize(w)
24484                 }); err != nil {
24485                         if err == io.EOF {
24486                                 chk(io.EOF)
24487                         }
24488                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24489                 }
24490                 if err := pcall(func() {
24491                         ((*(*(struct {
24492                                 Type ItemType
24493
24494                                 Name, Desc string
24495
24496                                 InvImg, WieldImg Texture
24497                                 WieldScale       [3]float32
24498
24499                                 StackMax uint16
24500
24501                                 Usable          bool
24502                                 CanPointLiquids bool
24503
24504                                 ToolCaps ToolCaps
24505
24506                                 Groups []Group
24507
24508                                 PlacePredict string
24509
24510                                 PlaceSnd, PlaceFailSnd SoundDef
24511
24512                                 PointRange float32
24513
24514                                 // Set index in Palette with "palette_index" item meta field,
24515                                 // this overrides Color.
24516                                 Palette Texture
24517                                 Color   color.NRGBA
24518
24519                                 // Texture overlays.
24520                                 InvOverlay, WieldOverlay Texture
24521
24522                                 ShortDesc string
24523                         }))(obj)).WieldOverlay).serialize(w)
24524                 }); err != nil {
24525                         if err == io.EOF {
24526                                 chk(io.EOF)
24527                         }
24528                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24529                 }
24530                 if len(([]byte((*(*(struct {
24531                         Type ItemType
24532
24533                         Name, Desc string
24534
24535                         InvImg, WieldImg Texture
24536                         WieldScale       [3]float32
24537
24538                         StackMax uint16
24539
24540                         Usable          bool
24541                         CanPointLiquids bool
24542
24543                         ToolCaps ToolCaps
24544
24545                         Groups []Group
24546
24547                         PlacePredict string
24548
24549                         PlaceSnd, PlaceFailSnd SoundDef
24550
24551                         PointRange float32
24552
24553                         // Set index in Palette with "palette_index" item meta field,
24554                         // this overrides Color.
24555                         Palette Texture
24556                         Color   color.NRGBA
24557
24558                         // Texture overlays.
24559                         InvOverlay, WieldOverlay Texture
24560
24561                         ShortDesc string
24562                 }))(obj)).ShortDesc))) > math.MaxUint16 {
24563                         chk(ErrTooLong)
24564                 }
24565                 {
24566                         x := uint16(len(([]byte((*(*(struct {
24567                                 Type ItemType
24568
24569                                 Name, Desc string
24570
24571                                 InvImg, WieldImg Texture
24572                                 WieldScale       [3]float32
24573
24574                                 StackMax uint16
24575
24576                                 Usable          bool
24577                                 CanPointLiquids bool
24578
24579                                 ToolCaps ToolCaps
24580
24581                                 Groups []Group
24582
24583                                 PlacePredict string
24584
24585                                 PlaceSnd, PlaceFailSnd SoundDef
24586
24587                                 PointRange float32
24588
24589                                 // Set index in Palette with "palette_index" item meta field,
24590                                 // this overrides Color.
24591                                 Palette Texture
24592                                 Color   color.NRGBA
24593
24594                                 // Texture overlays.
24595                                 InvOverlay, WieldOverlay Texture
24596
24597                                 ShortDesc string
24598                         }))(obj)).ShortDesc))))
24599                         write16(w, uint16(x))
24600                 }
24601                 {
24602                         _, err := w.Write(([]byte((*(*(struct {
24603                                 Type ItemType
24604
24605                                 Name, Desc string
24606
24607                                 InvImg, WieldImg Texture
24608                                 WieldScale       [3]float32
24609
24610                                 StackMax uint16
24611
24612                                 Usable          bool
24613                                 CanPointLiquids bool
24614
24615                                 ToolCaps ToolCaps
24616
24617                                 Groups []Group
24618
24619                                 PlacePredict string
24620
24621                                 PlaceSnd, PlaceFailSnd SoundDef
24622
24623                                 PointRange float32
24624
24625                                 // Set index in Palette with "palette_index" item meta field,
24626                                 // this overrides Color.
24627                                 Palette Texture
24628                                 Color   color.NRGBA
24629
24630                                 // Texture overlays.
24631                                 InvOverlay, WieldOverlay Texture
24632
24633                                 ShortDesc string
24634                         }))(obj)).ShortDesc))[:])
24635                         chk(err)
24636                 }
24637                 {
24638                         buf := w
24639                         w := ow
24640                         if len((buf.Bytes())) > math.MaxUint16 {
24641                                 chk(ErrTooLong)
24642                         }
24643                         {
24644                                 x := uint16(len((buf.Bytes())))
24645                                 write16(w, uint16(x))
24646                         }
24647                         {
24648                                 _, err := w.Write((buf.Bytes())[:])
24649                                 chk(err)
24650                         }
24651                 }
24652         }
24653 }
24654
24655 func (obj *ItemDef) deserialize(r io.Reader) {
24656         {
24657                 var n uint16
24658                 {
24659                         p := &n
24660                         *p = read16(r)
24661                 }
24662                 r := &io.LimitedReader{R: r, N: int64(n)}
24663                 {
24664                         var local300 uint8
24665                         local301 := uint8(6)
24666                         {
24667                                 p := &local300
24668                                 *p = read8(r)
24669                         }
24670                         if local300 != local301 {
24671                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local300))
24672                         }
24673                 }
24674                 if err := pcall(func() {
24675                         ((*(*(struct {
24676                                 Type ItemType
24677
24678                                 Name, Desc string
24679
24680                                 InvImg, WieldImg Texture
24681                                 WieldScale       [3]float32
24682
24683                                 StackMax uint16
24684
24685                                 Usable          bool
24686                                 CanPointLiquids bool
24687
24688                                 ToolCaps ToolCaps
24689
24690                                 Groups []Group
24691
24692                                 PlacePredict string
24693
24694                                 PlaceSnd, PlaceFailSnd SoundDef
24695
24696                                 PointRange float32
24697
24698                                 // Set index in Palette with "palette_index" item meta field,
24699                                 // this overrides Color.
24700                                 Palette Texture
24701                                 Color   color.NRGBA
24702
24703                                 // Texture overlays.
24704                                 InvOverlay, WieldOverlay Texture
24705
24706                                 ShortDesc string
24707                         }))(obj)).Type).deserialize(r)
24708                 }); err != nil {
24709                         if err == io.EOF {
24710                                 chk(io.EOF)
24711                         }
24712                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ItemType", err))
24713                 }
24714                 var local302 []uint8
24715                 var local303 uint16
24716                 {
24717                         p := &local303
24718                         *p = read16(r)
24719                 }
24720                 (local302) = make([]uint8, local303)
24721                 {
24722                         _, err := io.ReadFull(r, (local302)[:])
24723                         chk(err)
24724                 }
24725                 ((*(*(struct {
24726                         Type ItemType
24727
24728                         Name, Desc string
24729
24730                         InvImg, WieldImg Texture
24731                         WieldScale       [3]float32
24732
24733                         StackMax uint16
24734
24735                         Usable          bool
24736                         CanPointLiquids bool
24737
24738                         ToolCaps ToolCaps
24739
24740                         Groups []Group
24741
24742                         PlacePredict string
24743
24744                         PlaceSnd, PlaceFailSnd SoundDef
24745
24746                         PointRange float32
24747
24748                         // Set index in Palette with "palette_index" item meta field,
24749                         // this overrides Color.
24750                         Palette Texture
24751                         Color   color.NRGBA
24752
24753                         // Texture overlays.
24754                         InvOverlay, WieldOverlay Texture
24755
24756                         ShortDesc string
24757                 }))(obj)).Name) = string(local302)
24758                 var local304 []uint8
24759                 var local305 uint16
24760                 {
24761                         p := &local305
24762                         *p = read16(r)
24763                 }
24764                 (local304) = make([]uint8, local305)
24765                 {
24766                         _, err := io.ReadFull(r, (local304)[:])
24767                         chk(err)
24768                 }
24769                 ((*(*(struct {
24770                         Type ItemType
24771
24772                         Name, Desc string
24773
24774                         InvImg, WieldImg Texture
24775                         WieldScale       [3]float32
24776
24777                         StackMax uint16
24778
24779                         Usable          bool
24780                         CanPointLiquids bool
24781
24782                         ToolCaps ToolCaps
24783
24784                         Groups []Group
24785
24786                         PlacePredict string
24787
24788                         PlaceSnd, PlaceFailSnd SoundDef
24789
24790                         PointRange float32
24791
24792                         // Set index in Palette with "palette_index" item meta field,
24793                         // this overrides Color.
24794                         Palette Texture
24795                         Color   color.NRGBA
24796
24797                         // Texture overlays.
24798                         InvOverlay, WieldOverlay Texture
24799
24800                         ShortDesc string
24801                 }))(obj)).Desc) = string(local304)
24802                 if err := pcall(func() {
24803                         ((*(*(struct {
24804                                 Type ItemType
24805
24806                                 Name, Desc string
24807
24808                                 InvImg, WieldImg Texture
24809                                 WieldScale       [3]float32
24810
24811                                 StackMax uint16
24812
24813                                 Usable          bool
24814                                 CanPointLiquids bool
24815
24816                                 ToolCaps ToolCaps
24817
24818                                 Groups []Group
24819
24820                                 PlacePredict string
24821
24822                                 PlaceSnd, PlaceFailSnd SoundDef
24823
24824                                 PointRange float32
24825
24826                                 // Set index in Palette with "palette_index" item meta field,
24827                                 // this overrides Color.
24828                                 Palette Texture
24829                                 Color   color.NRGBA
24830
24831                                 // Texture overlays.
24832                                 InvOverlay, WieldOverlay Texture
24833
24834                                 ShortDesc string
24835                         }))(obj)).InvImg).deserialize(r)
24836                 }); err != nil {
24837                         if err == io.EOF {
24838                                 chk(io.EOF)
24839                         }
24840                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24841                 }
24842                 if err := pcall(func() {
24843                         ((*(*(struct {
24844                                 Type ItemType
24845
24846                                 Name, Desc string
24847
24848                                 InvImg, WieldImg Texture
24849                                 WieldScale       [3]float32
24850
24851                                 StackMax uint16
24852
24853                                 Usable          bool
24854                                 CanPointLiquids bool
24855
24856                                 ToolCaps ToolCaps
24857
24858                                 Groups []Group
24859
24860                                 PlacePredict string
24861
24862                                 PlaceSnd, PlaceFailSnd SoundDef
24863
24864                                 PointRange float32
24865
24866                                 // Set index in Palette with "palette_index" item meta field,
24867                                 // this overrides Color.
24868                                 Palette Texture
24869                                 Color   color.NRGBA
24870
24871                                 // Texture overlays.
24872                                 InvOverlay, WieldOverlay Texture
24873
24874                                 ShortDesc string
24875                         }))(obj)).WieldImg).deserialize(r)
24876                 }); err != nil {
24877                         if err == io.EOF {
24878                                 chk(io.EOF)
24879                         }
24880                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
24881                 }
24882                 for local306 := range (*(*(struct {
24883                         Type ItemType
24884
24885                         Name, Desc string
24886
24887                         InvImg, WieldImg Texture
24888                         WieldScale       [3]float32
24889
24890                         StackMax uint16
24891
24892                         Usable          bool
24893                         CanPointLiquids bool
24894
24895                         ToolCaps ToolCaps
24896
24897                         Groups []Group
24898
24899                         PlacePredict string
24900
24901                         PlaceSnd, PlaceFailSnd SoundDef
24902
24903                         PointRange float32
24904
24905                         // Set index in Palette with "palette_index" item meta field,
24906                         // this overrides Color.
24907                         Palette Texture
24908                         Color   color.NRGBA
24909
24910                         // Texture overlays.
24911                         InvOverlay, WieldOverlay Texture
24912
24913                         ShortDesc string
24914                 }))(obj)).WieldScale {
24915                         {
24916                                 p := &((*(*(struct {
24917                                         Type ItemType
24918
24919                                         Name, Desc string
24920
24921                                         InvImg, WieldImg Texture
24922                                         WieldScale       [3]float32
24923
24924                                         StackMax uint16
24925
24926                                         Usable          bool
24927                                         CanPointLiquids bool
24928
24929                                         ToolCaps ToolCaps
24930
24931                                         Groups []Group
24932
24933                                         PlacePredict string
24934
24935                                         PlaceSnd, PlaceFailSnd SoundDef
24936
24937                                         PointRange float32
24938
24939                                         // Set index in Palette with "palette_index" item meta field,
24940                                         // this overrides Color.
24941                                         Palette Texture
24942                                         Color   color.NRGBA
24943
24944                                         // Texture overlays.
24945                                         InvOverlay, WieldOverlay Texture
24946
24947                                         ShortDesc string
24948                                 }))(obj)).WieldScale)[local306]
24949                                 *p = math.Float32frombits(read32(r))
24950                         }
24951                 }
24952                 {
24953                         p := &(*(*(struct {
24954                                 Type ItemType
24955
24956                                 Name, Desc string
24957
24958                                 InvImg, WieldImg Texture
24959                                 WieldScale       [3]float32
24960
24961                                 StackMax uint16
24962
24963                                 Usable          bool
24964                                 CanPointLiquids bool
24965
24966                                 ToolCaps ToolCaps
24967
24968                                 Groups []Group
24969
24970                                 PlacePredict string
24971
24972                                 PlaceSnd, PlaceFailSnd SoundDef
24973
24974                                 PointRange float32
24975
24976                                 // Set index in Palette with "palette_index" item meta field,
24977                                 // this overrides Color.
24978                                 Palette Texture
24979                                 Color   color.NRGBA
24980
24981                                 // Texture overlays.
24982                                 InvOverlay, WieldOverlay Texture
24983
24984                                 ShortDesc string
24985                         }))(obj)).StackMax
24986                         *p = read16(r)
24987                 }
24988                 {
24989                         p := &(*(*(struct {
24990                                 Type ItemType
24991
24992                                 Name, Desc string
24993
24994                                 InvImg, WieldImg Texture
24995                                 WieldScale       [3]float32
24996
24997                                 StackMax uint16
24998
24999                                 Usable          bool
25000                                 CanPointLiquids bool
25001
25002                                 ToolCaps ToolCaps
25003
25004                                 Groups []Group
25005
25006                                 PlacePredict string
25007
25008                                 PlaceSnd, PlaceFailSnd SoundDef
25009
25010                                 PointRange float32
25011
25012                                 // Set index in Palette with "palette_index" item meta field,
25013                                 // this overrides Color.
25014                                 Palette Texture
25015                                 Color   color.NRGBA
25016
25017                                 // Texture overlays.
25018                                 InvOverlay, WieldOverlay Texture
25019
25020                                 ShortDesc string
25021                         }))(obj)).Usable
25022                         switch n := read8(r); n {
25023                         case 0:
25024                                 *p = false
25025                         case 1:
25026                                 *p = true
25027                         default:
25028                                 chk(fmt.Errorf("invalid bool: %d", n))
25029                         }
25030
25031                 }
25032                 {
25033                         p := &(*(*(struct {
25034                                 Type ItemType
25035
25036                                 Name, Desc string
25037
25038                                 InvImg, WieldImg Texture
25039                                 WieldScale       [3]float32
25040
25041                                 StackMax uint16
25042
25043                                 Usable          bool
25044                                 CanPointLiquids bool
25045
25046                                 ToolCaps ToolCaps
25047
25048                                 Groups []Group
25049
25050                                 PlacePredict string
25051
25052                                 PlaceSnd, PlaceFailSnd SoundDef
25053
25054                                 PointRange float32
25055
25056                                 // Set index in Palette with "palette_index" item meta field,
25057                                 // this overrides Color.
25058                                 Palette Texture
25059                                 Color   color.NRGBA
25060
25061                                 // Texture overlays.
25062                                 InvOverlay, WieldOverlay Texture
25063
25064                                 ShortDesc string
25065                         }))(obj)).CanPointLiquids
25066                         switch n := read8(r); n {
25067                         case 0:
25068                                 *p = false
25069                         case 1:
25070                                 *p = true
25071                         default:
25072                                 chk(fmt.Errorf("invalid bool: %d", n))
25073                         }
25074
25075                 }
25076                 if err := pcall(func() {
25077                         ((*(*(struct {
25078                                 Type ItemType
25079
25080                                 Name, Desc string
25081
25082                                 InvImg, WieldImg Texture
25083                                 WieldScale       [3]float32
25084
25085                                 StackMax uint16
25086
25087                                 Usable          bool
25088                                 CanPointLiquids bool
25089
25090                                 ToolCaps ToolCaps
25091
25092                                 Groups []Group
25093
25094                                 PlacePredict string
25095
25096                                 PlaceSnd, PlaceFailSnd SoundDef
25097
25098                                 PointRange float32
25099
25100                                 // Set index in Palette with "palette_index" item meta field,
25101                                 // this overrides Color.
25102                                 Palette Texture
25103                                 Color   color.NRGBA
25104
25105                                 // Texture overlays.
25106                                 InvOverlay, WieldOverlay Texture
25107
25108                                 ShortDesc string
25109                         }))(obj)).ToolCaps).deserialize(r)
25110                 }); err != nil {
25111                         if err == io.EOF {
25112                                 chk(io.EOF)
25113                         }
25114                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolCaps", err))
25115                 }
25116                 var local307 uint16
25117                 {
25118                         p := &local307
25119                         *p = read16(r)
25120                 }
25121                 ((*(*(struct {
25122                         Type ItemType
25123
25124                         Name, Desc string
25125
25126                         InvImg, WieldImg Texture
25127                         WieldScale       [3]float32
25128
25129                         StackMax uint16
25130
25131                         Usable          bool
25132                         CanPointLiquids bool
25133
25134                         ToolCaps ToolCaps
25135
25136                         Groups []Group
25137
25138                         PlacePredict string
25139
25140                         PlaceSnd, PlaceFailSnd SoundDef
25141
25142                         PointRange float32
25143
25144                         // Set index in Palette with "palette_index" item meta field,
25145                         // this overrides Color.
25146                         Palette Texture
25147                         Color   color.NRGBA
25148
25149                         // Texture overlays.
25150                         InvOverlay, WieldOverlay Texture
25151
25152                         ShortDesc string
25153                 }))(obj)).Groups) = make([]Group, local307)
25154                 for local308 := range (*(*(struct {
25155                         Type ItemType
25156
25157                         Name, Desc string
25158
25159                         InvImg, WieldImg Texture
25160                         WieldScale       [3]float32
25161
25162                         StackMax uint16
25163
25164                         Usable          bool
25165                         CanPointLiquids bool
25166
25167                         ToolCaps ToolCaps
25168
25169                         Groups []Group
25170
25171                         PlacePredict string
25172
25173                         PlaceSnd, PlaceFailSnd SoundDef
25174
25175                         PointRange float32
25176
25177                         // Set index in Palette with "palette_index" item meta field,
25178                         // this overrides Color.
25179                         Palette Texture
25180                         Color   color.NRGBA
25181
25182                         // Texture overlays.
25183                         InvOverlay, WieldOverlay Texture
25184
25185                         ShortDesc string
25186                 }))(obj)).Groups {
25187                         if err := pcall(func() {
25188                                 (((*(*(struct {
25189                                         Type ItemType
25190
25191                                         Name, Desc string
25192
25193                                         InvImg, WieldImg Texture
25194                                         WieldScale       [3]float32
25195
25196                                         StackMax uint16
25197
25198                                         Usable          bool
25199                                         CanPointLiquids bool
25200
25201                                         ToolCaps ToolCaps
25202
25203                                         Groups []Group
25204
25205                                         PlacePredict string
25206
25207                                         PlaceSnd, PlaceFailSnd SoundDef
25208
25209                                         PointRange float32
25210
25211                                         // Set index in Palette with "palette_index" item meta field,
25212                                         // this overrides Color.
25213                                         Palette Texture
25214                                         Color   color.NRGBA
25215
25216                                         // Texture overlays.
25217                                         InvOverlay, WieldOverlay Texture
25218
25219                                         ShortDesc string
25220                                 }))(obj)).Groups)[local308]).deserialize(r)
25221                         }); err != nil {
25222                                 if err == io.EOF {
25223                                         chk(io.EOF)
25224                                 }
25225                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
25226                         }
25227                 }
25228                 var local309 []uint8
25229                 var local310 uint16
25230                 {
25231                         p := &local310
25232                         *p = read16(r)
25233                 }
25234                 (local309) = make([]uint8, local310)
25235                 {
25236                         _, err := io.ReadFull(r, (local309)[:])
25237                         chk(err)
25238                 }
25239                 ((*(*(struct {
25240                         Type ItemType
25241
25242                         Name, Desc string
25243
25244                         InvImg, WieldImg Texture
25245                         WieldScale       [3]float32
25246
25247                         StackMax uint16
25248
25249                         Usable          bool
25250                         CanPointLiquids bool
25251
25252                         ToolCaps ToolCaps
25253
25254                         Groups []Group
25255
25256                         PlacePredict string
25257
25258                         PlaceSnd, PlaceFailSnd SoundDef
25259
25260                         PointRange float32
25261
25262                         // Set index in Palette with "palette_index" item meta field,
25263                         // this overrides Color.
25264                         Palette Texture
25265                         Color   color.NRGBA
25266
25267                         // Texture overlays.
25268                         InvOverlay, WieldOverlay Texture
25269
25270                         ShortDesc string
25271                 }))(obj)).PlacePredict) = string(local309)
25272                 if err := pcall(func() {
25273                         ((*(*(struct {
25274                                 Type ItemType
25275
25276                                 Name, Desc string
25277
25278                                 InvImg, WieldImg Texture
25279                                 WieldScale       [3]float32
25280
25281                                 StackMax uint16
25282
25283                                 Usable          bool
25284                                 CanPointLiquids bool
25285
25286                                 ToolCaps ToolCaps
25287
25288                                 Groups []Group
25289
25290                                 PlacePredict string
25291
25292                                 PlaceSnd, PlaceFailSnd SoundDef
25293
25294                                 PointRange float32
25295
25296                                 // Set index in Palette with "palette_index" item meta field,
25297                                 // this overrides Color.
25298                                 Palette Texture
25299                                 Color   color.NRGBA
25300
25301                                 // Texture overlays.
25302                                 InvOverlay, WieldOverlay Texture
25303
25304                                 ShortDesc string
25305                         }))(obj)).PlaceSnd).deserialize(r)
25306                 }); err != nil {
25307                         if err == io.EOF {
25308                                 chk(io.EOF)
25309                         }
25310                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
25311                 }
25312                 if err := pcall(func() {
25313                         ((*(*(struct {
25314                                 Type ItemType
25315
25316                                 Name, Desc string
25317
25318                                 InvImg, WieldImg Texture
25319                                 WieldScale       [3]float32
25320
25321                                 StackMax uint16
25322
25323                                 Usable          bool
25324                                 CanPointLiquids bool
25325
25326                                 ToolCaps ToolCaps
25327
25328                                 Groups []Group
25329
25330                                 PlacePredict string
25331
25332                                 PlaceSnd, PlaceFailSnd SoundDef
25333
25334                                 PointRange float32
25335
25336                                 // Set index in Palette with "palette_index" item meta field,
25337                                 // this overrides Color.
25338                                 Palette Texture
25339                                 Color   color.NRGBA
25340
25341                                 // Texture overlays.
25342                                 InvOverlay, WieldOverlay Texture
25343
25344                                 ShortDesc string
25345                         }))(obj)).PlaceFailSnd).deserialize(r)
25346                 }); err != nil {
25347                         if err == io.EOF {
25348                                 chk(io.EOF)
25349                         }
25350                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.SoundDef", err))
25351                 }
25352                 {
25353                         p := &(*(*(struct {
25354                                 Type ItemType
25355
25356                                 Name, Desc string
25357
25358                                 InvImg, WieldImg Texture
25359                                 WieldScale       [3]float32
25360
25361                                 StackMax uint16
25362
25363                                 Usable          bool
25364                                 CanPointLiquids bool
25365
25366                                 ToolCaps ToolCaps
25367
25368                                 Groups []Group
25369
25370                                 PlacePredict string
25371
25372                                 PlaceSnd, PlaceFailSnd SoundDef
25373
25374                                 PointRange float32
25375
25376                                 // Set index in Palette with "palette_index" item meta field,
25377                                 // this overrides Color.
25378                                 Palette Texture
25379                                 Color   color.NRGBA
25380
25381                                 // Texture overlays.
25382                                 InvOverlay, WieldOverlay Texture
25383
25384                                 ShortDesc string
25385                         }))(obj)).PointRange
25386                         *p = math.Float32frombits(read32(r))
25387                 }
25388                 if err := pcall(func() {
25389                         ((*(*(struct {
25390                                 Type ItemType
25391
25392                                 Name, Desc string
25393
25394                                 InvImg, WieldImg Texture
25395                                 WieldScale       [3]float32
25396
25397                                 StackMax uint16
25398
25399                                 Usable          bool
25400                                 CanPointLiquids bool
25401
25402                                 ToolCaps ToolCaps
25403
25404                                 Groups []Group
25405
25406                                 PlacePredict string
25407
25408                                 PlaceSnd, PlaceFailSnd SoundDef
25409
25410                                 PointRange float32
25411
25412                                 // Set index in Palette with "palette_index" item meta field,
25413                                 // this overrides Color.
25414                                 Palette Texture
25415                                 Color   color.NRGBA
25416
25417                                 // Texture overlays.
25418                                 InvOverlay, WieldOverlay Texture
25419
25420                                 ShortDesc string
25421                         }))(obj)).Palette).deserialize(r)
25422                 }); err != nil {
25423                         if err == io.EOF {
25424                                 chk(io.EOF)
25425                         }
25426                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
25427                 }
25428                 {
25429                         p := &(*(*(struct {
25430                                 Type ItemType
25431
25432                                 Name, Desc string
25433
25434                                 InvImg, WieldImg Texture
25435                                 WieldScale       [3]float32
25436
25437                                 StackMax uint16
25438
25439                                 Usable          bool
25440                                 CanPointLiquids bool
25441
25442                                 ToolCaps ToolCaps
25443
25444                                 Groups []Group
25445
25446                                 PlacePredict string
25447
25448                                 PlaceSnd, PlaceFailSnd SoundDef
25449
25450                                 PointRange float32
25451
25452                                 // Set index in Palette with "palette_index" item meta field,
25453                                 // this overrides Color.
25454                                 Palette Texture
25455                                 Color   color.NRGBA
25456
25457                                 // Texture overlays.
25458                                 InvOverlay, WieldOverlay Texture
25459
25460                                 ShortDesc string
25461                         }))(obj)).Color
25462                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
25463
25464                 }
25465                 if err := pcall(func() {
25466                         ((*(*(struct {
25467                                 Type ItemType
25468
25469                                 Name, Desc string
25470
25471                                 InvImg, WieldImg Texture
25472                                 WieldScale       [3]float32
25473
25474                                 StackMax uint16
25475
25476                                 Usable          bool
25477                                 CanPointLiquids bool
25478
25479                                 ToolCaps ToolCaps
25480
25481                                 Groups []Group
25482
25483                                 PlacePredict string
25484
25485                                 PlaceSnd, PlaceFailSnd SoundDef
25486
25487                                 PointRange float32
25488
25489                                 // Set index in Palette with "palette_index" item meta field,
25490                                 // this overrides Color.
25491                                 Palette Texture
25492                                 Color   color.NRGBA
25493
25494                                 // Texture overlays.
25495                                 InvOverlay, WieldOverlay Texture
25496
25497                                 ShortDesc string
25498                         }))(obj)).InvOverlay).deserialize(r)
25499                 }); err != nil {
25500                         if err == io.EOF {
25501                                 chk(io.EOF)
25502                         }
25503                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
25504                 }
25505                 if err := pcall(func() {
25506                         ((*(*(struct {
25507                                 Type ItemType
25508
25509                                 Name, Desc string
25510
25511                                 InvImg, WieldImg Texture
25512                                 WieldScale       [3]float32
25513
25514                                 StackMax uint16
25515
25516                                 Usable          bool
25517                                 CanPointLiquids bool
25518
25519                                 ToolCaps ToolCaps
25520
25521                                 Groups []Group
25522
25523                                 PlacePredict string
25524
25525                                 PlaceSnd, PlaceFailSnd SoundDef
25526
25527                                 PointRange float32
25528
25529                                 // Set index in Palette with "palette_index" item meta field,
25530                                 // this overrides Color.
25531                                 Palette Texture
25532                                 Color   color.NRGBA
25533
25534                                 // Texture overlays.
25535                                 InvOverlay, WieldOverlay Texture
25536
25537                                 ShortDesc string
25538                         }))(obj)).WieldOverlay).deserialize(r)
25539                 }); err != nil {
25540                         if err == io.EOF {
25541                                 chk(io.EOF)
25542                         }
25543                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
25544                 }
25545                 var local311 []uint8
25546                 var local312 uint16
25547                 {
25548                         p := &local312
25549                         *p = read16(r)
25550                 }
25551                 (local311) = make([]uint8, local312)
25552                 {
25553                         _, err := io.ReadFull(r, (local311)[:])
25554                         chk(err)
25555                 }
25556                 ((*(*(struct {
25557                         Type ItemType
25558
25559                         Name, Desc string
25560
25561                         InvImg, WieldImg Texture
25562                         WieldScale       [3]float32
25563
25564                         StackMax uint16
25565
25566                         Usable          bool
25567                         CanPointLiquids bool
25568
25569                         ToolCaps ToolCaps
25570
25571                         Groups []Group
25572
25573                         PlacePredict string
25574
25575                         PlaceSnd, PlaceFailSnd SoundDef
25576
25577                         PointRange float32
25578
25579                         // Set index in Palette with "palette_index" item meta field,
25580                         // this overrides Color.
25581                         Palette Texture
25582                         Color   color.NRGBA
25583
25584                         // Texture overlays.
25585                         InvOverlay, WieldOverlay Texture
25586
25587                         ShortDesc string
25588                 }))(obj)).ShortDesc) = string(local311)
25589                 if r.N > 0 {
25590                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
25591                 }
25592         }
25593 }
25594
25595 func (obj *SoundSrcType) serialize(w io.Writer) {
25596         {
25597                 x := *(*(uint8))(obj)
25598                 write8(w, uint8(x))
25599         }
25600 }
25601
25602 func (obj *SoundSrcType) deserialize(r io.Reader) {
25603         {
25604                 p := &*(*(uint8))(obj)
25605                 *p = read8(r)
25606         }
25607 }
25608
25609 func (obj *TileAnim) serialize(w io.Writer) {
25610         if err := pcall(func() {
25611                 ((*(*(struct {
25612                         Type AnimType
25613
25614                         //mt:if %s.Type == SpriteSheetAnim
25615                         AspectRatio [2]uint8
25616
25617                         //mt:if %s.Type == VerticalFrameAnim
25618                         NFrames [2]uint16
25619
25620                         //mt:if %s.Type != NoAnim
25621                         Duration float32 // in seconds
25622
25623                 }))(obj)).Type).serialize(w)
25624         }); err != nil {
25625                 if err == io.EOF {
25626                         chk(io.EOF)
25627                 }
25628                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AnimType", err))
25629         }
25630         if !((*(*(struct {
25631                 Type AnimType
25632
25633                 //mt:if %s.Type == SpriteSheetAnim
25634                 AspectRatio [2]uint8
25635
25636                 //mt:if %s.Type == VerticalFrameAnim
25637                 NFrames [2]uint16
25638
25639                 //mt:if %s.Type != NoAnim
25640                 Duration float32 // in seconds
25641
25642         }))(obj)).Type < maxAnim) {
25643                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25644         }
25645         if (*(*(struct {
25646                 Type AnimType
25647
25648                 //mt:if %s.Type == SpriteSheetAnim
25649                 AspectRatio [2]uint8
25650
25651                 //mt:if %s.Type == VerticalFrameAnim
25652                 NFrames [2]uint16
25653
25654                 //mt:if %s.Type != NoAnim
25655                 Duration float32 // in seconds
25656
25657         }))(obj)).Type == SpriteSheetAnim {
25658                 {
25659                         _, err := w.Write(((*(*(struct {
25660                                 Type AnimType
25661
25662                                 //mt:if %s.Type == SpriteSheetAnim
25663                                 AspectRatio [2]uint8
25664
25665                                 //mt:if %s.Type == VerticalFrameAnim
25666                                 NFrames [2]uint16
25667
25668                                 //mt:if %s.Type != NoAnim
25669                                 Duration float32 // in seconds
25670
25671                         }))(obj)).AspectRatio)[:])
25672                         chk(err)
25673                 }
25674         }
25675         if (*(*(struct {
25676                 Type AnimType
25677
25678                 //mt:if %s.Type == SpriteSheetAnim
25679                 AspectRatio [2]uint8
25680
25681                 //mt:if %s.Type == VerticalFrameAnim
25682                 NFrames [2]uint16
25683
25684                 //mt:if %s.Type != NoAnim
25685                 Duration float32 // in seconds
25686
25687         }))(obj)).Type == VerticalFrameAnim {
25688                 for local313 := range (*(*(struct {
25689                         Type AnimType
25690
25691                         //mt:if %s.Type == SpriteSheetAnim
25692                         AspectRatio [2]uint8
25693
25694                         //mt:if %s.Type == VerticalFrameAnim
25695                         NFrames [2]uint16
25696
25697                         //mt:if %s.Type != NoAnim
25698                         Duration float32 // in seconds
25699
25700                 }))(obj)).NFrames {
25701                         {
25702                                 x := ((*(*(struct {
25703                                         Type AnimType
25704
25705                                         //mt:if %s.Type == SpriteSheetAnim
25706                                         AspectRatio [2]uint8
25707
25708                                         //mt:if %s.Type == VerticalFrameAnim
25709                                         NFrames [2]uint16
25710
25711                                         //mt:if %s.Type != NoAnim
25712                                         Duration float32 // in seconds
25713
25714                                 }))(obj)).NFrames)[local313]
25715                                 write16(w, uint16(x))
25716                         }
25717                 }
25718         }
25719         if (*(*(struct {
25720                 Type AnimType
25721
25722                 //mt:if %s.Type == SpriteSheetAnim
25723                 AspectRatio [2]uint8
25724
25725                 //mt:if %s.Type == VerticalFrameAnim
25726                 NFrames [2]uint16
25727
25728                 //mt:if %s.Type != NoAnim
25729                 Duration float32 // in seconds
25730
25731         }))(obj)).Type != NoAnim {
25732                 {
25733                         x := (*(*(struct {
25734                                 Type AnimType
25735
25736                                 //mt:if %s.Type == SpriteSheetAnim
25737                                 AspectRatio [2]uint8
25738
25739                                 //mt:if %s.Type == VerticalFrameAnim
25740                                 NFrames [2]uint16
25741
25742                                 //mt:if %s.Type != NoAnim
25743                                 Duration float32 // in seconds
25744
25745                         }))(obj)).Duration
25746                         write32(w, math.Float32bits(x))
25747                 }
25748         }
25749 }
25750
25751 func (obj *TileAnim) deserialize(r io.Reader) {
25752         if err := pcall(func() {
25753                 ((*(*(struct {
25754                         Type AnimType
25755
25756                         //mt:if %s.Type == SpriteSheetAnim
25757                         AspectRatio [2]uint8
25758
25759                         //mt:if %s.Type == VerticalFrameAnim
25760                         NFrames [2]uint16
25761
25762                         //mt:if %s.Type != NoAnim
25763                         Duration float32 // in seconds
25764
25765                 }))(obj)).Type).deserialize(r)
25766         }); err != nil {
25767                 if err == io.EOF {
25768                         chk(io.EOF)
25769                 }
25770                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AnimType", err))
25771         }
25772         if !((*(*(struct {
25773                 Type AnimType
25774
25775                 //mt:if %s.Type == SpriteSheetAnim
25776                 AspectRatio [2]uint8
25777
25778                 //mt:if %s.Type == VerticalFrameAnim
25779                 NFrames [2]uint16
25780
25781                 //mt:if %s.Type != NoAnim
25782                 Duration float32 // in seconds
25783
25784         }))(obj)).Type < maxAnim) {
25785                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
25786         }
25787         if (*(*(struct {
25788                 Type AnimType
25789
25790                 //mt:if %s.Type == SpriteSheetAnim
25791                 AspectRatio [2]uint8
25792
25793                 //mt:if %s.Type == VerticalFrameAnim
25794                 NFrames [2]uint16
25795
25796                 //mt:if %s.Type != NoAnim
25797                 Duration float32 // in seconds
25798
25799         }))(obj)).Type == SpriteSheetAnim {
25800                 {
25801                         _, err := io.ReadFull(r, ((*(*(struct {
25802                                 Type AnimType
25803
25804                                 //mt:if %s.Type == SpriteSheetAnim
25805                                 AspectRatio [2]uint8
25806
25807                                 //mt:if %s.Type == VerticalFrameAnim
25808                                 NFrames [2]uint16
25809
25810                                 //mt:if %s.Type != NoAnim
25811                                 Duration float32 // in seconds
25812
25813                         }))(obj)).AspectRatio)[:])
25814                         chk(err)
25815                 }
25816         }
25817         if (*(*(struct {
25818                 Type AnimType
25819
25820                 //mt:if %s.Type == SpriteSheetAnim
25821                 AspectRatio [2]uint8
25822
25823                 //mt:if %s.Type == VerticalFrameAnim
25824                 NFrames [2]uint16
25825
25826                 //mt:if %s.Type != NoAnim
25827                 Duration float32 // in seconds
25828
25829         }))(obj)).Type == VerticalFrameAnim {
25830                 for local314 := range (*(*(struct {
25831                         Type AnimType
25832
25833                         //mt:if %s.Type == SpriteSheetAnim
25834                         AspectRatio [2]uint8
25835
25836                         //mt:if %s.Type == VerticalFrameAnim
25837                         NFrames [2]uint16
25838
25839                         //mt:if %s.Type != NoAnim
25840                         Duration float32 // in seconds
25841
25842                 }))(obj)).NFrames {
25843                         {
25844                                 p := &((*(*(struct {
25845                                         Type AnimType
25846
25847                                         //mt:if %s.Type == SpriteSheetAnim
25848                                         AspectRatio [2]uint8
25849
25850                                         //mt:if %s.Type == VerticalFrameAnim
25851                                         NFrames [2]uint16
25852
25853                                         //mt:if %s.Type != NoAnim
25854                                         Duration float32 // in seconds
25855
25856                                 }))(obj)).NFrames)[local314]
25857                                 *p = read16(r)
25858                         }
25859                 }
25860         }
25861         if (*(*(struct {
25862                 Type AnimType
25863
25864                 //mt:if %s.Type == SpriteSheetAnim
25865                 AspectRatio [2]uint8
25866
25867                 //mt:if %s.Type == VerticalFrameAnim
25868                 NFrames [2]uint16
25869
25870                 //mt:if %s.Type != NoAnim
25871                 Duration float32 // in seconds
25872
25873         }))(obj)).Type != NoAnim {
25874                 {
25875                         p := &(*(*(struct {
25876                                 Type AnimType
25877
25878                                 //mt:if %s.Type == SpriteSheetAnim
25879                                 AspectRatio [2]uint8
25880
25881                                 //mt:if %s.Type == VerticalFrameAnim
25882                                 NFrames [2]uint16
25883
25884                                 //mt:if %s.Type != NoAnim
25885                                 Duration float32 // in seconds
25886
25887                         }))(obj)).Duration
25888                         *p = math.Float32frombits(read32(r))
25889                 }
25890         }
25891 }
25892
25893 func (obj *Content) serialize(w io.Writer) {
25894         {
25895                 x := *(*(uint16))(obj)
25896                 write16(w, uint16(x))
25897         }
25898 }
25899
25900 func (obj *Content) deserialize(r io.Reader) {
25901         {
25902                 p := &*(*(uint16))(obj)
25903                 *p = read16(r)
25904         }
25905 }
25906
25907 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
25908         {
25909                 x := *(*(uint32))(obj)
25910                 write32(w, uint32(x))
25911         }
25912 }
25913
25914 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
25915         {
25916                 p := &*(*(uint32))(obj)
25917                 *p = read32(r)
25918         }
25919 }
25920
25921 func (obj *HUDID) serialize(w io.Writer) {
25922         {
25923                 x := *(*(uint32))(obj)
25924                 write32(w, uint32(x))
25925         }
25926 }
25927
25928 func (obj *HUDID) deserialize(r io.Reader) {
25929         {
25930                 p := &*(*(uint32))(obj)
25931                 *p = read32(r)
25932         }
25933 }
25934
25935 func (obj *HUD) serialize(w io.Writer) {
25936         if err := pcall(func() {
25937                 ((*(*(struct {
25938                         Type HUDType
25939
25940                         Pos      [2]float32
25941                         Name     string
25942                         Scale    [2]float32
25943                         Text     string
25944                         Number   uint32
25945                         Item     uint32
25946                         Dir      uint32
25947                         Align    [2]float32
25948                         Offset   [2]float32
25949                         WorldPos Pos
25950                         Size     [2]int32
25951                         ZIndex   int16
25952                         Text2    string
25953                 }))(obj)).Type).serialize(w)
25954         }); err != nil {
25955                 if err == io.EOF {
25956                         chk(io.EOF)
25957                 }
25958                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDType", err))
25959         }
25960         for local315 := range (*(*(struct {
25961                 Type HUDType
25962
25963                 Pos      [2]float32
25964                 Name     string
25965                 Scale    [2]float32
25966                 Text     string
25967                 Number   uint32
25968                 Item     uint32
25969                 Dir      uint32
25970                 Align    [2]float32
25971                 Offset   [2]float32
25972                 WorldPos Pos
25973                 Size     [2]int32
25974                 ZIndex   int16
25975                 Text2    string
25976         }))(obj)).Pos {
25977                 {
25978                         x := ((*(*(struct {
25979                                 Type HUDType
25980
25981                                 Pos      [2]float32
25982                                 Name     string
25983                                 Scale    [2]float32
25984                                 Text     string
25985                                 Number   uint32
25986                                 Item     uint32
25987                                 Dir      uint32
25988                                 Align    [2]float32
25989                                 Offset   [2]float32
25990                                 WorldPos Pos
25991                                 Size     [2]int32
25992                                 ZIndex   int16
25993                                 Text2    string
25994                         }))(obj)).Pos)[local315]
25995                         write32(w, math.Float32bits(x))
25996                 }
25997         }
25998         if len(([]byte((*(*(struct {
25999                 Type HUDType
26000
26001                 Pos      [2]float32
26002                 Name     string
26003                 Scale    [2]float32
26004                 Text     string
26005                 Number   uint32
26006                 Item     uint32
26007                 Dir      uint32
26008                 Align    [2]float32
26009                 Offset   [2]float32
26010                 WorldPos Pos
26011                 Size     [2]int32
26012                 ZIndex   int16
26013                 Text2    string
26014         }))(obj)).Name))) > math.MaxUint16 {
26015                 chk(ErrTooLong)
26016         }
26017         {
26018                 x := uint16(len(([]byte((*(*(struct {
26019                         Type HUDType
26020
26021                         Pos      [2]float32
26022                         Name     string
26023                         Scale    [2]float32
26024                         Text     string
26025                         Number   uint32
26026                         Item     uint32
26027                         Dir      uint32
26028                         Align    [2]float32
26029                         Offset   [2]float32
26030                         WorldPos Pos
26031                         Size     [2]int32
26032                         ZIndex   int16
26033                         Text2    string
26034                 }))(obj)).Name))))
26035                 write16(w, uint16(x))
26036         }
26037         {
26038                 _, err := w.Write(([]byte((*(*(struct {
26039                         Type HUDType
26040
26041                         Pos      [2]float32
26042                         Name     string
26043                         Scale    [2]float32
26044                         Text     string
26045                         Number   uint32
26046                         Item     uint32
26047                         Dir      uint32
26048                         Align    [2]float32
26049                         Offset   [2]float32
26050                         WorldPos Pos
26051                         Size     [2]int32
26052                         ZIndex   int16
26053                         Text2    string
26054                 }))(obj)).Name))[:])
26055                 chk(err)
26056         }
26057         for local316 := range (*(*(struct {
26058                 Type HUDType
26059
26060                 Pos      [2]float32
26061                 Name     string
26062                 Scale    [2]float32
26063                 Text     string
26064                 Number   uint32
26065                 Item     uint32
26066                 Dir      uint32
26067                 Align    [2]float32
26068                 Offset   [2]float32
26069                 WorldPos Pos
26070                 Size     [2]int32
26071                 ZIndex   int16
26072                 Text2    string
26073         }))(obj)).Scale {
26074                 {
26075                         x := ((*(*(struct {
26076                                 Type HUDType
26077
26078                                 Pos      [2]float32
26079                                 Name     string
26080                                 Scale    [2]float32
26081                                 Text     string
26082                                 Number   uint32
26083                                 Item     uint32
26084                                 Dir      uint32
26085                                 Align    [2]float32
26086                                 Offset   [2]float32
26087                                 WorldPos Pos
26088                                 Size     [2]int32
26089                                 ZIndex   int16
26090                                 Text2    string
26091                         }))(obj)).Scale)[local316]
26092                         write32(w, math.Float32bits(x))
26093                 }
26094         }
26095         if len(([]byte((*(*(struct {
26096                 Type HUDType
26097
26098                 Pos      [2]float32
26099                 Name     string
26100                 Scale    [2]float32
26101                 Text     string
26102                 Number   uint32
26103                 Item     uint32
26104                 Dir      uint32
26105                 Align    [2]float32
26106                 Offset   [2]float32
26107                 WorldPos Pos
26108                 Size     [2]int32
26109                 ZIndex   int16
26110                 Text2    string
26111         }))(obj)).Text))) > math.MaxUint16 {
26112                 chk(ErrTooLong)
26113         }
26114         {
26115                 x := uint16(len(([]byte((*(*(struct {
26116                         Type HUDType
26117
26118                         Pos      [2]float32
26119                         Name     string
26120                         Scale    [2]float32
26121                         Text     string
26122                         Number   uint32
26123                         Item     uint32
26124                         Dir      uint32
26125                         Align    [2]float32
26126                         Offset   [2]float32
26127                         WorldPos Pos
26128                         Size     [2]int32
26129                         ZIndex   int16
26130                         Text2    string
26131                 }))(obj)).Text))))
26132                 write16(w, uint16(x))
26133         }
26134         {
26135                 _, err := w.Write(([]byte((*(*(struct {
26136                         Type HUDType
26137
26138                         Pos      [2]float32
26139                         Name     string
26140                         Scale    [2]float32
26141                         Text     string
26142                         Number   uint32
26143                         Item     uint32
26144                         Dir      uint32
26145                         Align    [2]float32
26146                         Offset   [2]float32
26147                         WorldPos Pos
26148                         Size     [2]int32
26149                         ZIndex   int16
26150                         Text2    string
26151                 }))(obj)).Text))[:])
26152                 chk(err)
26153         }
26154         {
26155                 x := (*(*(struct {
26156                         Type HUDType
26157
26158                         Pos      [2]float32
26159                         Name     string
26160                         Scale    [2]float32
26161                         Text     string
26162                         Number   uint32
26163                         Item     uint32
26164                         Dir      uint32
26165                         Align    [2]float32
26166                         Offset   [2]float32
26167                         WorldPos Pos
26168                         Size     [2]int32
26169                         ZIndex   int16
26170                         Text2    string
26171                 }))(obj)).Number
26172                 write32(w, uint32(x))
26173         }
26174         {
26175                 x := (*(*(struct {
26176                         Type HUDType
26177
26178                         Pos      [2]float32
26179                         Name     string
26180                         Scale    [2]float32
26181                         Text     string
26182                         Number   uint32
26183                         Item     uint32
26184                         Dir      uint32
26185                         Align    [2]float32
26186                         Offset   [2]float32
26187                         WorldPos Pos
26188                         Size     [2]int32
26189                         ZIndex   int16
26190                         Text2    string
26191                 }))(obj)).Item
26192                 write32(w, uint32(x))
26193         }
26194         {
26195                 x := (*(*(struct {
26196                         Type HUDType
26197
26198                         Pos      [2]float32
26199                         Name     string
26200                         Scale    [2]float32
26201                         Text     string
26202                         Number   uint32
26203                         Item     uint32
26204                         Dir      uint32
26205                         Align    [2]float32
26206                         Offset   [2]float32
26207                         WorldPos Pos
26208                         Size     [2]int32
26209                         ZIndex   int16
26210                         Text2    string
26211                 }))(obj)).Dir
26212                 write32(w, uint32(x))
26213         }
26214         for local317 := range (*(*(struct {
26215                 Type HUDType
26216
26217                 Pos      [2]float32
26218                 Name     string
26219                 Scale    [2]float32
26220                 Text     string
26221                 Number   uint32
26222                 Item     uint32
26223                 Dir      uint32
26224                 Align    [2]float32
26225                 Offset   [2]float32
26226                 WorldPos Pos
26227                 Size     [2]int32
26228                 ZIndex   int16
26229                 Text2    string
26230         }))(obj)).Align {
26231                 {
26232                         x := ((*(*(struct {
26233                                 Type HUDType
26234
26235                                 Pos      [2]float32
26236                                 Name     string
26237                                 Scale    [2]float32
26238                                 Text     string
26239                                 Number   uint32
26240                                 Item     uint32
26241                                 Dir      uint32
26242                                 Align    [2]float32
26243                                 Offset   [2]float32
26244                                 WorldPos Pos
26245                                 Size     [2]int32
26246                                 ZIndex   int16
26247                                 Text2    string
26248                         }))(obj)).Align)[local317]
26249                         write32(w, math.Float32bits(x))
26250                 }
26251         }
26252         for local318 := range (*(*(struct {
26253                 Type HUDType
26254
26255                 Pos      [2]float32
26256                 Name     string
26257                 Scale    [2]float32
26258                 Text     string
26259                 Number   uint32
26260                 Item     uint32
26261                 Dir      uint32
26262                 Align    [2]float32
26263                 Offset   [2]float32
26264                 WorldPos Pos
26265                 Size     [2]int32
26266                 ZIndex   int16
26267                 Text2    string
26268         }))(obj)).Offset {
26269                 {
26270                         x := ((*(*(struct {
26271                                 Type HUDType
26272
26273                                 Pos      [2]float32
26274                                 Name     string
26275                                 Scale    [2]float32
26276                                 Text     string
26277                                 Number   uint32
26278                                 Item     uint32
26279                                 Dir      uint32
26280                                 Align    [2]float32
26281                                 Offset   [2]float32
26282                                 WorldPos Pos
26283                                 Size     [2]int32
26284                                 ZIndex   int16
26285                                 Text2    string
26286                         }))(obj)).Offset)[local318]
26287                         write32(w, math.Float32bits(x))
26288                 }
26289         }
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)).WorldPos).serialize(w)
26308         }); err != nil {
26309                 if err == io.EOF {
26310                         chk(io.EOF)
26311                 }
26312                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
26313         }
26314         for local319 := 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)).Size {
26331                 {
26332                         x := ((*(*(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)).Size)[local319]
26349                         write32(w, uint32(x))
26350                 }
26351         }
26352         {
26353                 x := (*(*(struct {
26354                         Type HUDType
26355
26356                         Pos      [2]float32
26357                         Name     string
26358                         Scale    [2]float32
26359                         Text     string
26360                         Number   uint32
26361                         Item     uint32
26362                         Dir      uint32
26363                         Align    [2]float32
26364                         Offset   [2]float32
26365                         WorldPos Pos
26366                         Size     [2]int32
26367                         ZIndex   int16
26368                         Text2    string
26369                 }))(obj)).ZIndex
26370                 write16(w, uint16(x))
26371         }
26372         if len(([]byte((*(*(struct {
26373                 Type HUDType
26374
26375                 Pos      [2]float32
26376                 Name     string
26377                 Scale    [2]float32
26378                 Text     string
26379                 Number   uint32
26380                 Item     uint32
26381                 Dir      uint32
26382                 Align    [2]float32
26383                 Offset   [2]float32
26384                 WorldPos Pos
26385                 Size     [2]int32
26386                 ZIndex   int16
26387                 Text2    string
26388         }))(obj)).Text2))) > math.MaxUint16 {
26389                 chk(ErrTooLong)
26390         }
26391         {
26392                 x := uint16(len(([]byte((*(*(struct {
26393                         Type HUDType
26394
26395                         Pos      [2]float32
26396                         Name     string
26397                         Scale    [2]float32
26398                         Text     string
26399                         Number   uint32
26400                         Item     uint32
26401                         Dir      uint32
26402                         Align    [2]float32
26403                         Offset   [2]float32
26404                         WorldPos Pos
26405                         Size     [2]int32
26406                         ZIndex   int16
26407                         Text2    string
26408                 }))(obj)).Text2))))
26409                 write16(w, uint16(x))
26410         }
26411         {
26412                 _, err := w.Write(([]byte((*(*(struct {
26413                         Type HUDType
26414
26415                         Pos      [2]float32
26416                         Name     string
26417                         Scale    [2]float32
26418                         Text     string
26419                         Number   uint32
26420                         Item     uint32
26421                         Dir      uint32
26422                         Align    [2]float32
26423                         Offset   [2]float32
26424                         WorldPos Pos
26425                         Size     [2]int32
26426                         ZIndex   int16
26427                         Text2    string
26428                 }))(obj)).Text2))[:])
26429                 chk(err)
26430         }
26431 }
26432
26433 func (obj *HUD) deserialize(r io.Reader) {
26434         if err := pcall(func() {
26435                 ((*(*(struct {
26436                         Type HUDType
26437
26438                         Pos      [2]float32
26439                         Name     string
26440                         Scale    [2]float32
26441                         Text     string
26442                         Number   uint32
26443                         Item     uint32
26444                         Dir      uint32
26445                         Align    [2]float32
26446                         Offset   [2]float32
26447                         WorldPos Pos
26448                         Size     [2]int32
26449                         ZIndex   int16
26450                         Text2    string
26451                 }))(obj)).Type).deserialize(r)
26452         }); err != nil {
26453                 if err == io.EOF {
26454                         chk(io.EOF)
26455                 }
26456                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.HUDType", err))
26457         }
26458         for local320 := range (*(*(struct {
26459                 Type HUDType
26460
26461                 Pos      [2]float32
26462                 Name     string
26463                 Scale    [2]float32
26464                 Text     string
26465                 Number   uint32
26466                 Item     uint32
26467                 Dir      uint32
26468                 Align    [2]float32
26469                 Offset   [2]float32
26470                 WorldPos Pos
26471                 Size     [2]int32
26472                 ZIndex   int16
26473                 Text2    string
26474         }))(obj)).Pos {
26475                 {
26476                         p := &((*(*(struct {
26477                                 Type HUDType
26478
26479                                 Pos      [2]float32
26480                                 Name     string
26481                                 Scale    [2]float32
26482                                 Text     string
26483                                 Number   uint32
26484                                 Item     uint32
26485                                 Dir      uint32
26486                                 Align    [2]float32
26487                                 Offset   [2]float32
26488                                 WorldPos Pos
26489                                 Size     [2]int32
26490                                 ZIndex   int16
26491                                 Text2    string
26492                         }))(obj)).Pos)[local320]
26493                         *p = math.Float32frombits(read32(r))
26494                 }
26495         }
26496         var local321 []uint8
26497         var local322 uint16
26498         {
26499                 p := &local322
26500                 *p = read16(r)
26501         }
26502         (local321) = make([]uint8, local322)
26503         {
26504                 _, err := io.ReadFull(r, (local321)[:])
26505                 chk(err)
26506         }
26507         ((*(*(struct {
26508                 Type HUDType
26509
26510                 Pos      [2]float32
26511                 Name     string
26512                 Scale    [2]float32
26513                 Text     string
26514                 Number   uint32
26515                 Item     uint32
26516                 Dir      uint32
26517                 Align    [2]float32
26518                 Offset   [2]float32
26519                 WorldPos Pos
26520                 Size     [2]int32
26521                 ZIndex   int16
26522                 Text2    string
26523         }))(obj)).Name) = string(local321)
26524         for local323 := range (*(*(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)).Scale {
26541                 {
26542                         p := &((*(*(struct {
26543                                 Type HUDType
26544
26545                                 Pos      [2]float32
26546                                 Name     string
26547                                 Scale    [2]float32
26548                                 Text     string
26549                                 Number   uint32
26550                                 Item     uint32
26551                                 Dir      uint32
26552                                 Align    [2]float32
26553                                 Offset   [2]float32
26554                                 WorldPos Pos
26555                                 Size     [2]int32
26556                                 ZIndex   int16
26557                                 Text2    string
26558                         }))(obj)).Scale)[local323]
26559                         *p = math.Float32frombits(read32(r))
26560                 }
26561         }
26562         var local324 []uint8
26563         var local325 uint16
26564         {
26565                 p := &local325
26566                 *p = read16(r)
26567         }
26568         (local324) = make([]uint8, local325)
26569         {
26570                 _, err := io.ReadFull(r, (local324)[:])
26571                 chk(err)
26572         }
26573         ((*(*(struct {
26574                 Type HUDType
26575
26576                 Pos      [2]float32
26577                 Name     string
26578                 Scale    [2]float32
26579                 Text     string
26580                 Number   uint32
26581                 Item     uint32
26582                 Dir      uint32
26583                 Align    [2]float32
26584                 Offset   [2]float32
26585                 WorldPos Pos
26586                 Size     [2]int32
26587                 ZIndex   int16
26588                 Text2    string
26589         }))(obj)).Text) = string(local324)
26590         {
26591                 p := &(*(*(struct {
26592                         Type HUDType
26593
26594                         Pos      [2]float32
26595                         Name     string
26596                         Scale    [2]float32
26597                         Text     string
26598                         Number   uint32
26599                         Item     uint32
26600                         Dir      uint32
26601                         Align    [2]float32
26602                         Offset   [2]float32
26603                         WorldPos Pos
26604                         Size     [2]int32
26605                         ZIndex   int16
26606                         Text2    string
26607                 }))(obj)).Number
26608                 *p = read32(r)
26609         }
26610         {
26611                 p := &(*(*(struct {
26612                         Type HUDType
26613
26614                         Pos      [2]float32
26615                         Name     string
26616                         Scale    [2]float32
26617                         Text     string
26618                         Number   uint32
26619                         Item     uint32
26620                         Dir      uint32
26621                         Align    [2]float32
26622                         Offset   [2]float32
26623                         WorldPos Pos
26624                         Size     [2]int32
26625                         ZIndex   int16
26626                         Text2    string
26627                 }))(obj)).Item
26628                 *p = read32(r)
26629         }
26630         {
26631                 p := &(*(*(struct {
26632                         Type HUDType
26633
26634                         Pos      [2]float32
26635                         Name     string
26636                         Scale    [2]float32
26637                         Text     string
26638                         Number   uint32
26639                         Item     uint32
26640                         Dir      uint32
26641                         Align    [2]float32
26642                         Offset   [2]float32
26643                         WorldPos Pos
26644                         Size     [2]int32
26645                         ZIndex   int16
26646                         Text2    string
26647                 }))(obj)).Dir
26648                 *p = read32(r)
26649         }
26650         for local326 := range (*(*(struct {
26651                 Type HUDType
26652
26653                 Pos      [2]float32
26654                 Name     string
26655                 Scale    [2]float32
26656                 Text     string
26657                 Number   uint32
26658                 Item     uint32
26659                 Dir      uint32
26660                 Align    [2]float32
26661                 Offset   [2]float32
26662                 WorldPos Pos
26663                 Size     [2]int32
26664                 ZIndex   int16
26665                 Text2    string
26666         }))(obj)).Align {
26667                 {
26668                         p := &((*(*(struct {
26669                                 Type HUDType
26670
26671                                 Pos      [2]float32
26672                                 Name     string
26673                                 Scale    [2]float32
26674                                 Text     string
26675                                 Number   uint32
26676                                 Item     uint32
26677                                 Dir      uint32
26678                                 Align    [2]float32
26679                                 Offset   [2]float32
26680                                 WorldPos Pos
26681                                 Size     [2]int32
26682                                 ZIndex   int16
26683                                 Text2    string
26684                         }))(obj)).Align)[local326]
26685                         *p = math.Float32frombits(read32(r))
26686                 }
26687         }
26688         for local327 := range (*(*(struct {
26689                 Type HUDType
26690
26691                 Pos      [2]float32
26692                 Name     string
26693                 Scale    [2]float32
26694                 Text     string
26695                 Number   uint32
26696                 Item     uint32
26697                 Dir      uint32
26698                 Align    [2]float32
26699                 Offset   [2]float32
26700                 WorldPos Pos
26701                 Size     [2]int32
26702                 ZIndex   int16
26703                 Text2    string
26704         }))(obj)).Offset {
26705                 {
26706                         p := &((*(*(struct {
26707                                 Type HUDType
26708
26709                                 Pos      [2]float32
26710                                 Name     string
26711                                 Scale    [2]float32
26712                                 Text     string
26713                                 Number   uint32
26714                                 Item     uint32
26715                                 Dir      uint32
26716                                 Align    [2]float32
26717                                 Offset   [2]float32
26718                                 WorldPos Pos
26719                                 Size     [2]int32
26720                                 ZIndex   int16
26721                                 Text2    string
26722                         }))(obj)).Offset)[local327]
26723                         *p = math.Float32frombits(read32(r))
26724                 }
26725         }
26726         if err := pcall(func() {
26727                 ((*(*(struct {
26728                         Type HUDType
26729
26730                         Pos      [2]float32
26731                         Name     string
26732                         Scale    [2]float32
26733                         Text     string
26734                         Number   uint32
26735                         Item     uint32
26736                         Dir      uint32
26737                         Align    [2]float32
26738                         Offset   [2]float32
26739                         WorldPos Pos
26740                         Size     [2]int32
26741                         ZIndex   int16
26742                         Text2    string
26743                 }))(obj)).WorldPos).deserialize(r)
26744         }); err != nil {
26745                 if err == io.EOF {
26746                         chk(io.EOF)
26747                 }
26748                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
26749         }
26750         for local328 := range (*(*(struct {
26751                 Type HUDType
26752
26753                 Pos      [2]float32
26754                 Name     string
26755                 Scale    [2]float32
26756                 Text     string
26757                 Number   uint32
26758                 Item     uint32
26759                 Dir      uint32
26760                 Align    [2]float32
26761                 Offset   [2]float32
26762                 WorldPos Pos
26763                 Size     [2]int32
26764                 ZIndex   int16
26765                 Text2    string
26766         }))(obj)).Size {
26767                 {
26768                         p := &((*(*(struct {
26769                                 Type HUDType
26770
26771                                 Pos      [2]float32
26772                                 Name     string
26773                                 Scale    [2]float32
26774                                 Text     string
26775                                 Number   uint32
26776                                 Item     uint32
26777                                 Dir      uint32
26778                                 Align    [2]float32
26779                                 Offset   [2]float32
26780                                 WorldPos Pos
26781                                 Size     [2]int32
26782                                 ZIndex   int16
26783                                 Text2    string
26784                         }))(obj)).Size)[local328]
26785                         *p = int32(read32(r))
26786                 }
26787         }
26788         {
26789                 p := &(*(*(struct {
26790                         Type HUDType
26791
26792                         Pos      [2]float32
26793                         Name     string
26794                         Scale    [2]float32
26795                         Text     string
26796                         Number   uint32
26797                         Item     uint32
26798                         Dir      uint32
26799                         Align    [2]float32
26800                         Offset   [2]float32
26801                         WorldPos Pos
26802                         Size     [2]int32
26803                         ZIndex   int16
26804                         Text2    string
26805                 }))(obj)).ZIndex
26806                 *p = int16(read16(r))
26807         }
26808         var local329 []uint8
26809         var local330 uint16
26810         {
26811                 p := &local330
26812                 *p = read16(r)
26813         }
26814         (local329) = make([]uint8, local330)
26815         {
26816                 _, err := io.ReadFull(r, (local329)[:])
26817                 chk(err)
26818         }
26819         ((*(*(struct {
26820                 Type HUDType
26821
26822                 Pos      [2]float32
26823                 Name     string
26824                 Scale    [2]float32
26825                 Text     string
26826                 Number   uint32
26827                 Item     uint32
26828                 Dir      uint32
26829                 Align    [2]float32
26830                 Offset   [2]float32
26831                 WorldPos Pos
26832                 Size     [2]int32
26833                 ZIndex   int16
26834                 Text2    string
26835         }))(obj)).Text2) = string(local329)
26836 }
26837
26838 func (obj *HUDField) serialize(w io.Writer) {
26839         {
26840                 x := *(*(uint8))(obj)
26841                 write8(w, uint8(x))
26842         }
26843 }
26844
26845 func (obj *HUDField) deserialize(r io.Reader) {
26846         {
26847                 p := &*(*(uint8))(obj)
26848                 *p = read8(r)
26849         }
26850 }
26851
26852 func (obj *HUDFlags) serialize(w io.Writer) {
26853         {
26854                 x := *(*(uint32))(obj)
26855                 write32(w, uint32(x))
26856         }
26857 }
26858
26859 func (obj *HUDFlags) deserialize(r io.Reader) {
26860         {
26861                 p := &*(*(uint32))(obj)
26862                 *p = read32(r)
26863         }
26864 }
26865
26866 func (obj *HotbarParam) serialize(w io.Writer) {
26867         {
26868                 x := *(*(uint16))(obj)
26869                 write16(w, uint16(x))
26870         }
26871 }
26872
26873 func (obj *HotbarParam) deserialize(r io.Reader) {
26874         {
26875                 p := &*(*(uint16))(obj)
26876                 *p = read16(r)
26877         }
26878 }
26879
26880 func (obj *Texture) serialize(w io.Writer) {
26881         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
26882                 chk(ErrTooLong)
26883         }
26884         {
26885                 x := uint16(len(([]byte(*(*(string))(obj)))))
26886                 write16(w, uint16(x))
26887         }
26888         {
26889                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
26890                 chk(err)
26891         }
26892 }
26893
26894 func (obj *Texture) deserialize(r io.Reader) {
26895         var local331 []uint8
26896         var local332 uint16
26897         {
26898                 p := &local332
26899                 *p = read16(r)
26900         }
26901         (local331) = make([]uint8, local332)
26902         {
26903                 _, err := io.ReadFull(r, (local331)[:])
26904                 chk(err)
26905         }
26906         (*(*(string))(obj)) = string(local331)
26907 }
26908
26909 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
26910         {
26911                 x := *(*(uint8))(obj)
26912                 write8(w, uint8(x))
26913         }
26914 }
26915
26916 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
26917         {
26918                 p := &*(*(uint8))(obj)
26919                 *p = read8(r)
26920         }
26921 }
26922
26923 func (obj *ModChanSig) serialize(w io.Writer) {
26924         {
26925                 x := *(*(uint8))(obj)
26926                 write8(w, uint8(x))
26927         }
26928 }
26929
26930 func (obj *ModChanSig) deserialize(r io.Reader) {
26931         {
26932                 p := &*(*(uint8))(obj)
26933                 *p = read8(r)
26934         }
26935 }
26936
26937 func (obj *AOProps) serialize(w io.Writer) {
26938         {
26939                 local333 := uint8(4)
26940                 {
26941                         x := local333
26942                         write8(w, uint8(x))
26943                 }
26944         }
26945         {
26946                 x := (*(*(struct {
26947                         MaxHP            uint16 // Player only.
26948                         CollideWithNodes bool
26949                         Weight           float32 // deprecated
26950                         ColBox, SelBox   Box
26951                         Pointable        bool
26952                         Visual           string
26953                         VisualSize       [3]float32
26954                         Textures         []Texture
26955                         SpriteSheetSize  [2]int16 // in sprites.
26956                         SpritePos        [2]int16 // in sprite sheet.
26957                         Visible          bool
26958                         MakeFootstepSnds bool
26959                         RotateSpeed      float32 // in radians per second.
26960                         Mesh             string
26961                         Colors           []color.NRGBA
26962                         CollideWithAOs   bool
26963                         StepHeight       float32
26964                         FaceRotateDir    bool
26965                         FaceRotateDirOff float32 // in degrees.
26966                         BackfaceCull     bool
26967                         Nametag          string
26968                         NametagColor     color.NRGBA
26969                         FaceRotateSpeed  float32 // in degrees per second.
26970                         Infotext         string
26971                         Itemstring       string
26972                         Glow             int8
26973                         MaxBreath        uint16  // Player only.
26974                         EyeHeight        float32 // Player only.
26975                         ZoomFOV          float32 // in degrees. Player only.
26976                         UseTextureAlpha  bool
26977                         DmgTextureMod    Texture // suffix
26978                         Shaded           bool
26979                         ShowOnMinimap    bool
26980                         NametagBG        color.NRGBA
26981                 }))(obj)).MaxHP
26982                 write16(w, uint16(x))
26983         }
26984         {
26985                 x := (*(*(struct {
26986                         MaxHP            uint16 // Player only.
26987                         CollideWithNodes bool
26988                         Weight           float32 // deprecated
26989                         ColBox, SelBox   Box
26990                         Pointable        bool
26991                         Visual           string
26992                         VisualSize       [3]float32
26993                         Textures         []Texture
26994                         SpriteSheetSize  [2]int16 // in sprites.
26995                         SpritePos        [2]int16 // in sprite sheet.
26996                         Visible          bool
26997                         MakeFootstepSnds bool
26998                         RotateSpeed      float32 // in radians per second.
26999                         Mesh             string
27000                         Colors           []color.NRGBA
27001                         CollideWithAOs   bool
27002                         StepHeight       float32
27003                         FaceRotateDir    bool
27004                         FaceRotateDirOff float32 // in degrees.
27005                         BackfaceCull     bool
27006                         Nametag          string
27007                         NametagColor     color.NRGBA
27008                         FaceRotateSpeed  float32 // in degrees per second.
27009                         Infotext         string
27010                         Itemstring       string
27011                         Glow             int8
27012                         MaxBreath        uint16  // Player only.
27013                         EyeHeight        float32 // Player only.
27014                         ZoomFOV          float32 // in degrees. Player only.
27015                         UseTextureAlpha  bool
27016                         DmgTextureMod    Texture // suffix
27017                         Shaded           bool
27018                         ShowOnMinimap    bool
27019                         NametagBG        color.NRGBA
27020                 }))(obj)).CollideWithNodes
27021                 if x {
27022                         write8(w, 1)
27023                 } else {
27024                         write8(w, 0)
27025                 }
27026
27027         }
27028         {
27029                 x := (*(*(struct {
27030                         MaxHP            uint16 // Player only.
27031                         CollideWithNodes bool
27032                         Weight           float32 // deprecated
27033                         ColBox, SelBox   Box
27034                         Pointable        bool
27035                         Visual           string
27036                         VisualSize       [3]float32
27037                         Textures         []Texture
27038                         SpriteSheetSize  [2]int16 // in sprites.
27039                         SpritePos        [2]int16 // in sprite sheet.
27040                         Visible          bool
27041                         MakeFootstepSnds bool
27042                         RotateSpeed      float32 // in radians per second.
27043                         Mesh             string
27044                         Colors           []color.NRGBA
27045                         CollideWithAOs   bool
27046                         StepHeight       float32
27047                         FaceRotateDir    bool
27048                         FaceRotateDirOff float32 // in degrees.
27049                         BackfaceCull     bool
27050                         Nametag          string
27051                         NametagColor     color.NRGBA
27052                         FaceRotateSpeed  float32 // in degrees per second.
27053                         Infotext         string
27054                         Itemstring       string
27055                         Glow             int8
27056                         MaxBreath        uint16  // Player only.
27057                         EyeHeight        float32 // Player only.
27058                         ZoomFOV          float32 // in degrees. Player only.
27059                         UseTextureAlpha  bool
27060                         DmgTextureMod    Texture // suffix
27061                         Shaded           bool
27062                         ShowOnMinimap    bool
27063                         NametagBG        color.NRGBA
27064                 }))(obj)).Weight
27065                 write32(w, math.Float32bits(x))
27066         }
27067         if err := pcall(func() {
27068                 ((*(*(struct {
27069                         MaxHP            uint16 // Player only.
27070                         CollideWithNodes bool
27071                         Weight           float32 // deprecated
27072                         ColBox, SelBox   Box
27073                         Pointable        bool
27074                         Visual           string
27075                         VisualSize       [3]float32
27076                         Textures         []Texture
27077                         SpriteSheetSize  [2]int16 // in sprites.
27078                         SpritePos        [2]int16 // in sprite sheet.
27079                         Visible          bool
27080                         MakeFootstepSnds bool
27081                         RotateSpeed      float32 // in radians per second.
27082                         Mesh             string
27083                         Colors           []color.NRGBA
27084                         CollideWithAOs   bool
27085                         StepHeight       float32
27086                         FaceRotateDir    bool
27087                         FaceRotateDirOff float32 // in degrees.
27088                         BackfaceCull     bool
27089                         Nametag          string
27090                         NametagColor     color.NRGBA
27091                         FaceRotateSpeed  float32 // in degrees per second.
27092                         Infotext         string
27093                         Itemstring       string
27094                         Glow             int8
27095                         MaxBreath        uint16  // Player only.
27096                         EyeHeight        float32 // Player only.
27097                         ZoomFOV          float32 // in degrees. Player only.
27098                         UseTextureAlpha  bool
27099                         DmgTextureMod    Texture // suffix
27100                         Shaded           bool
27101                         ShowOnMinimap    bool
27102                         NametagBG        color.NRGBA
27103                 }))(obj)).ColBox).serialize(w)
27104         }); err != nil {
27105                 if err == io.EOF {
27106                         chk(io.EOF)
27107                 }
27108                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
27109         }
27110         if err := pcall(func() {
27111                 ((*(*(struct {
27112                         MaxHP            uint16 // Player only.
27113                         CollideWithNodes bool
27114                         Weight           float32 // deprecated
27115                         ColBox, SelBox   Box
27116                         Pointable        bool
27117                         Visual           string
27118                         VisualSize       [3]float32
27119                         Textures         []Texture
27120                         SpriteSheetSize  [2]int16 // in sprites.
27121                         SpritePos        [2]int16 // in sprite sheet.
27122                         Visible          bool
27123                         MakeFootstepSnds bool
27124                         RotateSpeed      float32 // in radians per second.
27125                         Mesh             string
27126                         Colors           []color.NRGBA
27127                         CollideWithAOs   bool
27128                         StepHeight       float32
27129                         FaceRotateDir    bool
27130                         FaceRotateDirOff float32 // in degrees.
27131                         BackfaceCull     bool
27132                         Nametag          string
27133                         NametagColor     color.NRGBA
27134                         FaceRotateSpeed  float32 // in degrees per second.
27135                         Infotext         string
27136                         Itemstring       string
27137                         Glow             int8
27138                         MaxBreath        uint16  // Player only.
27139                         EyeHeight        float32 // Player only.
27140                         ZoomFOV          float32 // in degrees. Player only.
27141                         UseTextureAlpha  bool
27142                         DmgTextureMod    Texture // suffix
27143                         Shaded           bool
27144                         ShowOnMinimap    bool
27145                         NametagBG        color.NRGBA
27146                 }))(obj)).SelBox).serialize(w)
27147         }); err != nil {
27148                 if err == io.EOF {
27149                         chk(io.EOF)
27150                 }
27151                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
27152         }
27153         {
27154                 x := (*(*(struct {
27155                         MaxHP            uint16 // Player only.
27156                         CollideWithNodes bool
27157                         Weight           float32 // deprecated
27158                         ColBox, SelBox   Box
27159                         Pointable        bool
27160                         Visual           string
27161                         VisualSize       [3]float32
27162                         Textures         []Texture
27163                         SpriteSheetSize  [2]int16 // in sprites.
27164                         SpritePos        [2]int16 // in sprite sheet.
27165                         Visible          bool
27166                         MakeFootstepSnds bool
27167                         RotateSpeed      float32 // in radians per second.
27168                         Mesh             string
27169                         Colors           []color.NRGBA
27170                         CollideWithAOs   bool
27171                         StepHeight       float32
27172                         FaceRotateDir    bool
27173                         FaceRotateDirOff float32 // in degrees.
27174                         BackfaceCull     bool
27175                         Nametag          string
27176                         NametagColor     color.NRGBA
27177                         FaceRotateSpeed  float32 // in degrees per second.
27178                         Infotext         string
27179                         Itemstring       string
27180                         Glow             int8
27181                         MaxBreath        uint16  // Player only.
27182                         EyeHeight        float32 // Player only.
27183                         ZoomFOV          float32 // in degrees. Player only.
27184                         UseTextureAlpha  bool
27185                         DmgTextureMod    Texture // suffix
27186                         Shaded           bool
27187                         ShowOnMinimap    bool
27188                         NametagBG        color.NRGBA
27189                 }))(obj)).Pointable
27190                 if x {
27191                         write8(w, 1)
27192                 } else {
27193                         write8(w, 0)
27194                 }
27195
27196         }
27197         if len(([]byte((*(*(struct {
27198                 MaxHP            uint16 // Player only.
27199                 CollideWithNodes bool
27200                 Weight           float32 // deprecated
27201                 ColBox, SelBox   Box
27202                 Pointable        bool
27203                 Visual           string
27204                 VisualSize       [3]float32
27205                 Textures         []Texture
27206                 SpriteSheetSize  [2]int16 // in sprites.
27207                 SpritePos        [2]int16 // in sprite sheet.
27208                 Visible          bool
27209                 MakeFootstepSnds bool
27210                 RotateSpeed      float32 // in radians per second.
27211                 Mesh             string
27212                 Colors           []color.NRGBA
27213                 CollideWithAOs   bool
27214                 StepHeight       float32
27215                 FaceRotateDir    bool
27216                 FaceRotateDirOff float32 // in degrees.
27217                 BackfaceCull     bool
27218                 Nametag          string
27219                 NametagColor     color.NRGBA
27220                 FaceRotateSpeed  float32 // in degrees per second.
27221                 Infotext         string
27222                 Itemstring       string
27223                 Glow             int8
27224                 MaxBreath        uint16  // Player only.
27225                 EyeHeight        float32 // Player only.
27226                 ZoomFOV          float32 // in degrees. Player only.
27227                 UseTextureAlpha  bool
27228                 DmgTextureMod    Texture // suffix
27229                 Shaded           bool
27230                 ShowOnMinimap    bool
27231                 NametagBG        color.NRGBA
27232         }))(obj)).Visual))) > math.MaxUint16 {
27233                 chk(ErrTooLong)
27234         }
27235         {
27236                 x := uint16(len(([]byte((*(*(struct {
27237                         MaxHP            uint16 // Player only.
27238                         CollideWithNodes bool
27239                         Weight           float32 // deprecated
27240                         ColBox, SelBox   Box
27241                         Pointable        bool
27242                         Visual           string
27243                         VisualSize       [3]float32
27244                         Textures         []Texture
27245                         SpriteSheetSize  [2]int16 // in sprites.
27246                         SpritePos        [2]int16 // in sprite sheet.
27247                         Visible          bool
27248                         MakeFootstepSnds bool
27249                         RotateSpeed      float32 // in radians per second.
27250                         Mesh             string
27251                         Colors           []color.NRGBA
27252                         CollideWithAOs   bool
27253                         StepHeight       float32
27254                         FaceRotateDir    bool
27255                         FaceRotateDirOff float32 // in degrees.
27256                         BackfaceCull     bool
27257                         Nametag          string
27258                         NametagColor     color.NRGBA
27259                         FaceRotateSpeed  float32 // in degrees per second.
27260                         Infotext         string
27261                         Itemstring       string
27262                         Glow             int8
27263                         MaxBreath        uint16  // Player only.
27264                         EyeHeight        float32 // Player only.
27265                         ZoomFOV          float32 // in degrees. Player only.
27266                         UseTextureAlpha  bool
27267                         DmgTextureMod    Texture // suffix
27268                         Shaded           bool
27269                         ShowOnMinimap    bool
27270                         NametagBG        color.NRGBA
27271                 }))(obj)).Visual))))
27272                 write16(w, uint16(x))
27273         }
27274         {
27275                 _, err := w.Write(([]byte((*(*(struct {
27276                         MaxHP            uint16 // Player only.
27277                         CollideWithNodes bool
27278                         Weight           float32 // deprecated
27279                         ColBox, SelBox   Box
27280                         Pointable        bool
27281                         Visual           string
27282                         VisualSize       [3]float32
27283                         Textures         []Texture
27284                         SpriteSheetSize  [2]int16 // in sprites.
27285                         SpritePos        [2]int16 // in sprite sheet.
27286                         Visible          bool
27287                         MakeFootstepSnds bool
27288                         RotateSpeed      float32 // in radians per second.
27289                         Mesh             string
27290                         Colors           []color.NRGBA
27291                         CollideWithAOs   bool
27292                         StepHeight       float32
27293                         FaceRotateDir    bool
27294                         FaceRotateDirOff float32 // in degrees.
27295                         BackfaceCull     bool
27296                         Nametag          string
27297                         NametagColor     color.NRGBA
27298                         FaceRotateSpeed  float32 // in degrees per second.
27299                         Infotext         string
27300                         Itemstring       string
27301                         Glow             int8
27302                         MaxBreath        uint16  // Player only.
27303                         EyeHeight        float32 // Player only.
27304                         ZoomFOV          float32 // in degrees. Player only.
27305                         UseTextureAlpha  bool
27306                         DmgTextureMod    Texture // suffix
27307                         Shaded           bool
27308                         ShowOnMinimap    bool
27309                         NametagBG        color.NRGBA
27310                 }))(obj)).Visual))[:])
27311                 chk(err)
27312         }
27313         for local334 := range (*(*(struct {
27314                 MaxHP            uint16 // Player only.
27315                 CollideWithNodes bool
27316                 Weight           float32 // deprecated
27317                 ColBox, SelBox   Box
27318                 Pointable        bool
27319                 Visual           string
27320                 VisualSize       [3]float32
27321                 Textures         []Texture
27322                 SpriteSheetSize  [2]int16 // in sprites.
27323                 SpritePos        [2]int16 // in sprite sheet.
27324                 Visible          bool
27325                 MakeFootstepSnds bool
27326                 RotateSpeed      float32 // in radians per second.
27327                 Mesh             string
27328                 Colors           []color.NRGBA
27329                 CollideWithAOs   bool
27330                 StepHeight       float32
27331                 FaceRotateDir    bool
27332                 FaceRotateDirOff float32 // in degrees.
27333                 BackfaceCull     bool
27334                 Nametag          string
27335                 NametagColor     color.NRGBA
27336                 FaceRotateSpeed  float32 // in degrees per second.
27337                 Infotext         string
27338                 Itemstring       string
27339                 Glow             int8
27340                 MaxBreath        uint16  // Player only.
27341                 EyeHeight        float32 // Player only.
27342                 ZoomFOV          float32 // in degrees. Player only.
27343                 UseTextureAlpha  bool
27344                 DmgTextureMod    Texture // suffix
27345                 Shaded           bool
27346                 ShowOnMinimap    bool
27347                 NametagBG        color.NRGBA
27348         }))(obj)).VisualSize {
27349                 {
27350                         x := ((*(*(struct {
27351                                 MaxHP            uint16 // Player only.
27352                                 CollideWithNodes bool
27353                                 Weight           float32 // deprecated
27354                                 ColBox, SelBox   Box
27355                                 Pointable        bool
27356                                 Visual           string
27357                                 VisualSize       [3]float32
27358                                 Textures         []Texture
27359                                 SpriteSheetSize  [2]int16 // in sprites.
27360                                 SpritePos        [2]int16 // in sprite sheet.
27361                                 Visible          bool
27362                                 MakeFootstepSnds bool
27363                                 RotateSpeed      float32 // in radians per second.
27364                                 Mesh             string
27365                                 Colors           []color.NRGBA
27366                                 CollideWithAOs   bool
27367                                 StepHeight       float32
27368                                 FaceRotateDir    bool
27369                                 FaceRotateDirOff float32 // in degrees.
27370                                 BackfaceCull     bool
27371                                 Nametag          string
27372                                 NametagColor     color.NRGBA
27373                                 FaceRotateSpeed  float32 // in degrees per second.
27374                                 Infotext         string
27375                                 Itemstring       string
27376                                 Glow             int8
27377                                 MaxBreath        uint16  // Player only.
27378                                 EyeHeight        float32 // Player only.
27379                                 ZoomFOV          float32 // in degrees. Player only.
27380                                 UseTextureAlpha  bool
27381                                 DmgTextureMod    Texture // suffix
27382                                 Shaded           bool
27383                                 ShowOnMinimap    bool
27384                                 NametagBG        color.NRGBA
27385                         }))(obj)).VisualSize)[local334]
27386                         write32(w, math.Float32bits(x))
27387                 }
27388         }
27389         if len(((*(*(struct {
27390                 MaxHP            uint16 // Player only.
27391                 CollideWithNodes bool
27392                 Weight           float32 // deprecated
27393                 ColBox, SelBox   Box
27394                 Pointable        bool
27395                 Visual           string
27396                 VisualSize       [3]float32
27397                 Textures         []Texture
27398                 SpriteSheetSize  [2]int16 // in sprites.
27399                 SpritePos        [2]int16 // in sprite sheet.
27400                 Visible          bool
27401                 MakeFootstepSnds bool
27402                 RotateSpeed      float32 // in radians per second.
27403                 Mesh             string
27404                 Colors           []color.NRGBA
27405                 CollideWithAOs   bool
27406                 StepHeight       float32
27407                 FaceRotateDir    bool
27408                 FaceRotateDirOff float32 // in degrees.
27409                 BackfaceCull     bool
27410                 Nametag          string
27411                 NametagColor     color.NRGBA
27412                 FaceRotateSpeed  float32 // in degrees per second.
27413                 Infotext         string
27414                 Itemstring       string
27415                 Glow             int8
27416                 MaxBreath        uint16  // Player only.
27417                 EyeHeight        float32 // Player only.
27418                 ZoomFOV          float32 // in degrees. Player only.
27419                 UseTextureAlpha  bool
27420                 DmgTextureMod    Texture // suffix
27421                 Shaded           bool
27422                 ShowOnMinimap    bool
27423                 NametagBG        color.NRGBA
27424         }))(obj)).Textures)) > math.MaxUint16 {
27425                 chk(ErrTooLong)
27426         }
27427         {
27428                 x := uint16(len(((*(*(struct {
27429                         MaxHP            uint16 // Player only.
27430                         CollideWithNodes bool
27431                         Weight           float32 // deprecated
27432                         ColBox, SelBox   Box
27433                         Pointable        bool
27434                         Visual           string
27435                         VisualSize       [3]float32
27436                         Textures         []Texture
27437                         SpriteSheetSize  [2]int16 // in sprites.
27438                         SpritePos        [2]int16 // in sprite sheet.
27439                         Visible          bool
27440                         MakeFootstepSnds bool
27441                         RotateSpeed      float32 // in radians per second.
27442                         Mesh             string
27443                         Colors           []color.NRGBA
27444                         CollideWithAOs   bool
27445                         StepHeight       float32
27446                         FaceRotateDir    bool
27447                         FaceRotateDirOff float32 // in degrees.
27448                         BackfaceCull     bool
27449                         Nametag          string
27450                         NametagColor     color.NRGBA
27451                         FaceRotateSpeed  float32 // in degrees per second.
27452                         Infotext         string
27453                         Itemstring       string
27454                         Glow             int8
27455                         MaxBreath        uint16  // Player only.
27456                         EyeHeight        float32 // Player only.
27457                         ZoomFOV          float32 // in degrees. Player only.
27458                         UseTextureAlpha  bool
27459                         DmgTextureMod    Texture // suffix
27460                         Shaded           bool
27461                         ShowOnMinimap    bool
27462                         NametagBG        color.NRGBA
27463                 }))(obj)).Textures)))
27464                 write16(w, uint16(x))
27465         }
27466         for local335 := range (*(*(struct {
27467                 MaxHP            uint16 // Player only.
27468                 CollideWithNodes bool
27469                 Weight           float32 // deprecated
27470                 ColBox, SelBox   Box
27471                 Pointable        bool
27472                 Visual           string
27473                 VisualSize       [3]float32
27474                 Textures         []Texture
27475                 SpriteSheetSize  [2]int16 // in sprites.
27476                 SpritePos        [2]int16 // in sprite sheet.
27477                 Visible          bool
27478                 MakeFootstepSnds bool
27479                 RotateSpeed      float32 // in radians per second.
27480                 Mesh             string
27481                 Colors           []color.NRGBA
27482                 CollideWithAOs   bool
27483                 StepHeight       float32
27484                 FaceRotateDir    bool
27485                 FaceRotateDirOff float32 // in degrees.
27486                 BackfaceCull     bool
27487                 Nametag          string
27488                 NametagColor     color.NRGBA
27489                 FaceRotateSpeed  float32 // in degrees per second.
27490                 Infotext         string
27491                 Itemstring       string
27492                 Glow             int8
27493                 MaxBreath        uint16  // Player only.
27494                 EyeHeight        float32 // Player only.
27495                 ZoomFOV          float32 // in degrees. Player only.
27496                 UseTextureAlpha  bool
27497                 DmgTextureMod    Texture // suffix
27498                 Shaded           bool
27499                 ShowOnMinimap    bool
27500                 NametagBG        color.NRGBA
27501         }))(obj)).Textures {
27502                 if err := pcall(func() {
27503                         (((*(*(struct {
27504                                 MaxHP            uint16 // Player only.
27505                                 CollideWithNodes bool
27506                                 Weight           float32 // deprecated
27507                                 ColBox, SelBox   Box
27508                                 Pointable        bool
27509                                 Visual           string
27510                                 VisualSize       [3]float32
27511                                 Textures         []Texture
27512                                 SpriteSheetSize  [2]int16 // in sprites.
27513                                 SpritePos        [2]int16 // in sprite sheet.
27514                                 Visible          bool
27515                                 MakeFootstepSnds bool
27516                                 RotateSpeed      float32 // in radians per second.
27517                                 Mesh             string
27518                                 Colors           []color.NRGBA
27519                                 CollideWithAOs   bool
27520                                 StepHeight       float32
27521                                 FaceRotateDir    bool
27522                                 FaceRotateDirOff float32 // in degrees.
27523                                 BackfaceCull     bool
27524                                 Nametag          string
27525                                 NametagColor     color.NRGBA
27526                                 FaceRotateSpeed  float32 // in degrees per second.
27527                                 Infotext         string
27528                                 Itemstring       string
27529                                 Glow             int8
27530                                 MaxBreath        uint16  // Player only.
27531                                 EyeHeight        float32 // Player only.
27532                                 ZoomFOV          float32 // in degrees. Player only.
27533                                 UseTextureAlpha  bool
27534                                 DmgTextureMod    Texture // suffix
27535                                 Shaded           bool
27536                                 ShowOnMinimap    bool
27537                                 NametagBG        color.NRGBA
27538                         }))(obj)).Textures)[local335]).serialize(w)
27539                 }); err != nil {
27540                         if err == io.EOF {
27541                                 chk(io.EOF)
27542                         }
27543                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
27544                 }
27545         }
27546         for local336 := range (*(*(struct {
27547                 MaxHP            uint16 // Player only.
27548                 CollideWithNodes bool
27549                 Weight           float32 // deprecated
27550                 ColBox, SelBox   Box
27551                 Pointable        bool
27552                 Visual           string
27553                 VisualSize       [3]float32
27554                 Textures         []Texture
27555                 SpriteSheetSize  [2]int16 // in sprites.
27556                 SpritePos        [2]int16 // in sprite sheet.
27557                 Visible          bool
27558                 MakeFootstepSnds bool
27559                 RotateSpeed      float32 // in radians per second.
27560                 Mesh             string
27561                 Colors           []color.NRGBA
27562                 CollideWithAOs   bool
27563                 StepHeight       float32
27564                 FaceRotateDir    bool
27565                 FaceRotateDirOff float32 // in degrees.
27566                 BackfaceCull     bool
27567                 Nametag          string
27568                 NametagColor     color.NRGBA
27569                 FaceRotateSpeed  float32 // in degrees per second.
27570                 Infotext         string
27571                 Itemstring       string
27572                 Glow             int8
27573                 MaxBreath        uint16  // Player only.
27574                 EyeHeight        float32 // Player only.
27575                 ZoomFOV          float32 // in degrees. Player only.
27576                 UseTextureAlpha  bool
27577                 DmgTextureMod    Texture // suffix
27578                 Shaded           bool
27579                 ShowOnMinimap    bool
27580                 NametagBG        color.NRGBA
27581         }))(obj)).SpriteSheetSize {
27582                 {
27583                         x := ((*(*(struct {
27584                                 MaxHP            uint16 // Player only.
27585                                 CollideWithNodes bool
27586                                 Weight           float32 // deprecated
27587                                 ColBox, SelBox   Box
27588                                 Pointable        bool
27589                                 Visual           string
27590                                 VisualSize       [3]float32
27591                                 Textures         []Texture
27592                                 SpriteSheetSize  [2]int16 // in sprites.
27593                                 SpritePos        [2]int16 // in sprite sheet.
27594                                 Visible          bool
27595                                 MakeFootstepSnds bool
27596                                 RotateSpeed      float32 // in radians per second.
27597                                 Mesh             string
27598                                 Colors           []color.NRGBA
27599                                 CollideWithAOs   bool
27600                                 StepHeight       float32
27601                                 FaceRotateDir    bool
27602                                 FaceRotateDirOff float32 // in degrees.
27603                                 BackfaceCull     bool
27604                                 Nametag          string
27605                                 NametagColor     color.NRGBA
27606                                 FaceRotateSpeed  float32 // in degrees per second.
27607                                 Infotext         string
27608                                 Itemstring       string
27609                                 Glow             int8
27610                                 MaxBreath        uint16  // Player only.
27611                                 EyeHeight        float32 // Player only.
27612                                 ZoomFOV          float32 // in degrees. Player only.
27613                                 UseTextureAlpha  bool
27614                                 DmgTextureMod    Texture // suffix
27615                                 Shaded           bool
27616                                 ShowOnMinimap    bool
27617                                 NametagBG        color.NRGBA
27618                         }))(obj)).SpriteSheetSize)[local336]
27619                         write16(w, uint16(x))
27620                 }
27621         }
27622         for local337 := range (*(*(struct {
27623                 MaxHP            uint16 // Player only.
27624                 CollideWithNodes bool
27625                 Weight           float32 // deprecated
27626                 ColBox, SelBox   Box
27627                 Pointable        bool
27628                 Visual           string
27629                 VisualSize       [3]float32
27630                 Textures         []Texture
27631                 SpriteSheetSize  [2]int16 // in sprites.
27632                 SpritePos        [2]int16 // in sprite sheet.
27633                 Visible          bool
27634                 MakeFootstepSnds bool
27635                 RotateSpeed      float32 // in radians per second.
27636                 Mesh             string
27637                 Colors           []color.NRGBA
27638                 CollideWithAOs   bool
27639                 StepHeight       float32
27640                 FaceRotateDir    bool
27641                 FaceRotateDirOff float32 // in degrees.
27642                 BackfaceCull     bool
27643                 Nametag          string
27644                 NametagColor     color.NRGBA
27645                 FaceRotateSpeed  float32 // in degrees per second.
27646                 Infotext         string
27647                 Itemstring       string
27648                 Glow             int8
27649                 MaxBreath        uint16  // Player only.
27650                 EyeHeight        float32 // Player only.
27651                 ZoomFOV          float32 // in degrees. Player only.
27652                 UseTextureAlpha  bool
27653                 DmgTextureMod    Texture // suffix
27654                 Shaded           bool
27655                 ShowOnMinimap    bool
27656                 NametagBG        color.NRGBA
27657         }))(obj)).SpritePos {
27658                 {
27659                         x := ((*(*(struct {
27660                                 MaxHP            uint16 // Player only.
27661                                 CollideWithNodes bool
27662                                 Weight           float32 // deprecated
27663                                 ColBox, SelBox   Box
27664                                 Pointable        bool
27665                                 Visual           string
27666                                 VisualSize       [3]float32
27667                                 Textures         []Texture
27668                                 SpriteSheetSize  [2]int16 // in sprites.
27669                                 SpritePos        [2]int16 // in sprite sheet.
27670                                 Visible          bool
27671                                 MakeFootstepSnds bool
27672                                 RotateSpeed      float32 // in radians per second.
27673                                 Mesh             string
27674                                 Colors           []color.NRGBA
27675                                 CollideWithAOs   bool
27676                                 StepHeight       float32
27677                                 FaceRotateDir    bool
27678                                 FaceRotateDirOff float32 // in degrees.
27679                                 BackfaceCull     bool
27680                                 Nametag          string
27681                                 NametagColor     color.NRGBA
27682                                 FaceRotateSpeed  float32 // in degrees per second.
27683                                 Infotext         string
27684                                 Itemstring       string
27685                                 Glow             int8
27686                                 MaxBreath        uint16  // Player only.
27687                                 EyeHeight        float32 // Player only.
27688                                 ZoomFOV          float32 // in degrees. Player only.
27689                                 UseTextureAlpha  bool
27690                                 DmgTextureMod    Texture // suffix
27691                                 Shaded           bool
27692                                 ShowOnMinimap    bool
27693                                 NametagBG        color.NRGBA
27694                         }))(obj)).SpritePos)[local337]
27695                         write16(w, uint16(x))
27696                 }
27697         }
27698         {
27699                 x := (*(*(struct {
27700                         MaxHP            uint16 // Player only.
27701                         CollideWithNodes bool
27702                         Weight           float32 // deprecated
27703                         ColBox, SelBox   Box
27704                         Pointable        bool
27705                         Visual           string
27706                         VisualSize       [3]float32
27707                         Textures         []Texture
27708                         SpriteSheetSize  [2]int16 // in sprites.
27709                         SpritePos        [2]int16 // in sprite sheet.
27710                         Visible          bool
27711                         MakeFootstepSnds bool
27712                         RotateSpeed      float32 // in radians per second.
27713                         Mesh             string
27714                         Colors           []color.NRGBA
27715                         CollideWithAOs   bool
27716                         StepHeight       float32
27717                         FaceRotateDir    bool
27718                         FaceRotateDirOff float32 // in degrees.
27719                         BackfaceCull     bool
27720                         Nametag          string
27721                         NametagColor     color.NRGBA
27722                         FaceRotateSpeed  float32 // in degrees per second.
27723                         Infotext         string
27724                         Itemstring       string
27725                         Glow             int8
27726                         MaxBreath        uint16  // Player only.
27727                         EyeHeight        float32 // Player only.
27728                         ZoomFOV          float32 // in degrees. Player only.
27729                         UseTextureAlpha  bool
27730                         DmgTextureMod    Texture // suffix
27731                         Shaded           bool
27732                         ShowOnMinimap    bool
27733                         NametagBG        color.NRGBA
27734                 }))(obj)).Visible
27735                 if x {
27736                         write8(w, 1)
27737                 } else {
27738                         write8(w, 0)
27739                 }
27740
27741         }
27742         {
27743                 x := (*(*(struct {
27744                         MaxHP            uint16 // Player only.
27745                         CollideWithNodes bool
27746                         Weight           float32 // deprecated
27747                         ColBox, SelBox   Box
27748                         Pointable        bool
27749                         Visual           string
27750                         VisualSize       [3]float32
27751                         Textures         []Texture
27752                         SpriteSheetSize  [2]int16 // in sprites.
27753                         SpritePos        [2]int16 // in sprite sheet.
27754                         Visible          bool
27755                         MakeFootstepSnds bool
27756                         RotateSpeed      float32 // in radians per second.
27757                         Mesh             string
27758                         Colors           []color.NRGBA
27759                         CollideWithAOs   bool
27760                         StepHeight       float32
27761                         FaceRotateDir    bool
27762                         FaceRotateDirOff float32 // in degrees.
27763                         BackfaceCull     bool
27764                         Nametag          string
27765                         NametagColor     color.NRGBA
27766                         FaceRotateSpeed  float32 // in degrees per second.
27767                         Infotext         string
27768                         Itemstring       string
27769                         Glow             int8
27770                         MaxBreath        uint16  // Player only.
27771                         EyeHeight        float32 // Player only.
27772                         ZoomFOV          float32 // in degrees. Player only.
27773                         UseTextureAlpha  bool
27774                         DmgTextureMod    Texture // suffix
27775                         Shaded           bool
27776                         ShowOnMinimap    bool
27777                         NametagBG        color.NRGBA
27778                 }))(obj)).MakeFootstepSnds
27779                 if x {
27780                         write8(w, 1)
27781                 } else {
27782                         write8(w, 0)
27783                 }
27784
27785         }
27786         {
27787                 x := (*(*(struct {
27788                         MaxHP            uint16 // Player only.
27789                         CollideWithNodes bool
27790                         Weight           float32 // deprecated
27791                         ColBox, SelBox   Box
27792                         Pointable        bool
27793                         Visual           string
27794                         VisualSize       [3]float32
27795                         Textures         []Texture
27796                         SpriteSheetSize  [2]int16 // in sprites.
27797                         SpritePos        [2]int16 // in sprite sheet.
27798                         Visible          bool
27799                         MakeFootstepSnds bool
27800                         RotateSpeed      float32 // in radians per second.
27801                         Mesh             string
27802                         Colors           []color.NRGBA
27803                         CollideWithAOs   bool
27804                         StepHeight       float32
27805                         FaceRotateDir    bool
27806                         FaceRotateDirOff float32 // in degrees.
27807                         BackfaceCull     bool
27808                         Nametag          string
27809                         NametagColor     color.NRGBA
27810                         FaceRotateSpeed  float32 // in degrees per second.
27811                         Infotext         string
27812                         Itemstring       string
27813                         Glow             int8
27814                         MaxBreath        uint16  // Player only.
27815                         EyeHeight        float32 // Player only.
27816                         ZoomFOV          float32 // in degrees. Player only.
27817                         UseTextureAlpha  bool
27818                         DmgTextureMod    Texture // suffix
27819                         Shaded           bool
27820                         ShowOnMinimap    bool
27821                         NametagBG        color.NRGBA
27822                 }))(obj)).RotateSpeed
27823                 write32(w, math.Float32bits(x))
27824         }
27825         if len(([]byte((*(*(struct {
27826                 MaxHP            uint16 // Player only.
27827                 CollideWithNodes bool
27828                 Weight           float32 // deprecated
27829                 ColBox, SelBox   Box
27830                 Pointable        bool
27831                 Visual           string
27832                 VisualSize       [3]float32
27833                 Textures         []Texture
27834                 SpriteSheetSize  [2]int16 // in sprites.
27835                 SpritePos        [2]int16 // in sprite sheet.
27836                 Visible          bool
27837                 MakeFootstepSnds bool
27838                 RotateSpeed      float32 // in radians per second.
27839                 Mesh             string
27840                 Colors           []color.NRGBA
27841                 CollideWithAOs   bool
27842                 StepHeight       float32
27843                 FaceRotateDir    bool
27844                 FaceRotateDirOff float32 // in degrees.
27845                 BackfaceCull     bool
27846                 Nametag          string
27847                 NametagColor     color.NRGBA
27848                 FaceRotateSpeed  float32 // in degrees per second.
27849                 Infotext         string
27850                 Itemstring       string
27851                 Glow             int8
27852                 MaxBreath        uint16  // Player only.
27853                 EyeHeight        float32 // Player only.
27854                 ZoomFOV          float32 // in degrees. Player only.
27855                 UseTextureAlpha  bool
27856                 DmgTextureMod    Texture // suffix
27857                 Shaded           bool
27858                 ShowOnMinimap    bool
27859                 NametagBG        color.NRGBA
27860         }))(obj)).Mesh))) > math.MaxUint16 {
27861                 chk(ErrTooLong)
27862         }
27863         {
27864                 x := uint16(len(([]byte((*(*(struct {
27865                         MaxHP            uint16 // Player only.
27866                         CollideWithNodes bool
27867                         Weight           float32 // deprecated
27868                         ColBox, SelBox   Box
27869                         Pointable        bool
27870                         Visual           string
27871                         VisualSize       [3]float32
27872                         Textures         []Texture
27873                         SpriteSheetSize  [2]int16 // in sprites.
27874                         SpritePos        [2]int16 // in sprite sheet.
27875                         Visible          bool
27876                         MakeFootstepSnds bool
27877                         RotateSpeed      float32 // in radians per second.
27878                         Mesh             string
27879                         Colors           []color.NRGBA
27880                         CollideWithAOs   bool
27881                         StepHeight       float32
27882                         FaceRotateDir    bool
27883                         FaceRotateDirOff float32 // in degrees.
27884                         BackfaceCull     bool
27885                         Nametag          string
27886                         NametagColor     color.NRGBA
27887                         FaceRotateSpeed  float32 // in degrees per second.
27888                         Infotext         string
27889                         Itemstring       string
27890                         Glow             int8
27891                         MaxBreath        uint16  // Player only.
27892                         EyeHeight        float32 // Player only.
27893                         ZoomFOV          float32 // in degrees. Player only.
27894                         UseTextureAlpha  bool
27895                         DmgTextureMod    Texture // suffix
27896                         Shaded           bool
27897                         ShowOnMinimap    bool
27898                         NametagBG        color.NRGBA
27899                 }))(obj)).Mesh))))
27900                 write16(w, uint16(x))
27901         }
27902         {
27903                 _, err := w.Write(([]byte((*(*(struct {
27904                         MaxHP            uint16 // Player only.
27905                         CollideWithNodes bool
27906                         Weight           float32 // deprecated
27907                         ColBox, SelBox   Box
27908                         Pointable        bool
27909                         Visual           string
27910                         VisualSize       [3]float32
27911                         Textures         []Texture
27912                         SpriteSheetSize  [2]int16 // in sprites.
27913                         SpritePos        [2]int16 // in sprite sheet.
27914                         Visible          bool
27915                         MakeFootstepSnds bool
27916                         RotateSpeed      float32 // in radians per second.
27917                         Mesh             string
27918                         Colors           []color.NRGBA
27919                         CollideWithAOs   bool
27920                         StepHeight       float32
27921                         FaceRotateDir    bool
27922                         FaceRotateDirOff float32 // in degrees.
27923                         BackfaceCull     bool
27924                         Nametag          string
27925                         NametagColor     color.NRGBA
27926                         FaceRotateSpeed  float32 // in degrees per second.
27927                         Infotext         string
27928                         Itemstring       string
27929                         Glow             int8
27930                         MaxBreath        uint16  // Player only.
27931                         EyeHeight        float32 // Player only.
27932                         ZoomFOV          float32 // in degrees. Player only.
27933                         UseTextureAlpha  bool
27934                         DmgTextureMod    Texture // suffix
27935                         Shaded           bool
27936                         ShowOnMinimap    bool
27937                         NametagBG        color.NRGBA
27938                 }))(obj)).Mesh))[:])
27939                 chk(err)
27940         }
27941         if len(((*(*(struct {
27942                 MaxHP            uint16 // Player only.
27943                 CollideWithNodes bool
27944                 Weight           float32 // deprecated
27945                 ColBox, SelBox   Box
27946                 Pointable        bool
27947                 Visual           string
27948                 VisualSize       [3]float32
27949                 Textures         []Texture
27950                 SpriteSheetSize  [2]int16 // in sprites.
27951                 SpritePos        [2]int16 // in sprite sheet.
27952                 Visible          bool
27953                 MakeFootstepSnds bool
27954                 RotateSpeed      float32 // in radians per second.
27955                 Mesh             string
27956                 Colors           []color.NRGBA
27957                 CollideWithAOs   bool
27958                 StepHeight       float32
27959                 FaceRotateDir    bool
27960                 FaceRotateDirOff float32 // in degrees.
27961                 BackfaceCull     bool
27962                 Nametag          string
27963                 NametagColor     color.NRGBA
27964                 FaceRotateSpeed  float32 // in degrees per second.
27965                 Infotext         string
27966                 Itemstring       string
27967                 Glow             int8
27968                 MaxBreath        uint16  // Player only.
27969                 EyeHeight        float32 // Player only.
27970                 ZoomFOV          float32 // in degrees. Player only.
27971                 UseTextureAlpha  bool
27972                 DmgTextureMod    Texture // suffix
27973                 Shaded           bool
27974                 ShowOnMinimap    bool
27975                 NametagBG        color.NRGBA
27976         }))(obj)).Colors)) > math.MaxUint16 {
27977                 chk(ErrTooLong)
27978         }
27979         {
27980                 x := uint16(len(((*(*(struct {
27981                         MaxHP            uint16 // Player only.
27982                         CollideWithNodes bool
27983                         Weight           float32 // deprecated
27984                         ColBox, SelBox   Box
27985                         Pointable        bool
27986                         Visual           string
27987                         VisualSize       [3]float32
27988                         Textures         []Texture
27989                         SpriteSheetSize  [2]int16 // in sprites.
27990                         SpritePos        [2]int16 // in sprite sheet.
27991                         Visible          bool
27992                         MakeFootstepSnds bool
27993                         RotateSpeed      float32 // in radians per second.
27994                         Mesh             string
27995                         Colors           []color.NRGBA
27996                         CollideWithAOs   bool
27997                         StepHeight       float32
27998                         FaceRotateDir    bool
27999                         FaceRotateDirOff float32 // in degrees.
28000                         BackfaceCull     bool
28001                         Nametag          string
28002                         NametagColor     color.NRGBA
28003                         FaceRotateSpeed  float32 // in degrees per second.
28004                         Infotext         string
28005                         Itemstring       string
28006                         Glow             int8
28007                         MaxBreath        uint16  // Player only.
28008                         EyeHeight        float32 // Player only.
28009                         ZoomFOV          float32 // in degrees. Player only.
28010                         UseTextureAlpha  bool
28011                         DmgTextureMod    Texture // suffix
28012                         Shaded           bool
28013                         ShowOnMinimap    bool
28014                         NametagBG        color.NRGBA
28015                 }))(obj)).Colors)))
28016                 write16(w, uint16(x))
28017         }
28018         for local338 := range (*(*(struct {
28019                 MaxHP            uint16 // Player only.
28020                 CollideWithNodes bool
28021                 Weight           float32 // deprecated
28022                 ColBox, SelBox   Box
28023                 Pointable        bool
28024                 Visual           string
28025                 VisualSize       [3]float32
28026                 Textures         []Texture
28027                 SpriteSheetSize  [2]int16 // in sprites.
28028                 SpritePos        [2]int16 // in sprite sheet.
28029                 Visible          bool
28030                 MakeFootstepSnds bool
28031                 RotateSpeed      float32 // in radians per second.
28032                 Mesh             string
28033                 Colors           []color.NRGBA
28034                 CollideWithAOs   bool
28035                 StepHeight       float32
28036                 FaceRotateDir    bool
28037                 FaceRotateDirOff float32 // in degrees.
28038                 BackfaceCull     bool
28039                 Nametag          string
28040                 NametagColor     color.NRGBA
28041                 FaceRotateSpeed  float32 // in degrees per second.
28042                 Infotext         string
28043                 Itemstring       string
28044                 Glow             int8
28045                 MaxBreath        uint16  // Player only.
28046                 EyeHeight        float32 // Player only.
28047                 ZoomFOV          float32 // in degrees. Player only.
28048                 UseTextureAlpha  bool
28049                 DmgTextureMod    Texture // suffix
28050                 Shaded           bool
28051                 ShowOnMinimap    bool
28052                 NametagBG        color.NRGBA
28053         }))(obj)).Colors {
28054                 {
28055                         x := ((*(*(struct {
28056                                 MaxHP            uint16 // Player only.
28057                                 CollideWithNodes bool
28058                                 Weight           float32 // deprecated
28059                                 ColBox, SelBox   Box
28060                                 Pointable        bool
28061                                 Visual           string
28062                                 VisualSize       [3]float32
28063                                 Textures         []Texture
28064                                 SpriteSheetSize  [2]int16 // in sprites.
28065                                 SpritePos        [2]int16 // in sprite sheet.
28066                                 Visible          bool
28067                                 MakeFootstepSnds bool
28068                                 RotateSpeed      float32 // in radians per second.
28069                                 Mesh             string
28070                                 Colors           []color.NRGBA
28071                                 CollideWithAOs   bool
28072                                 StepHeight       float32
28073                                 FaceRotateDir    bool
28074                                 FaceRotateDirOff float32 // in degrees.
28075                                 BackfaceCull     bool
28076                                 Nametag          string
28077                                 NametagColor     color.NRGBA
28078                                 FaceRotateSpeed  float32 // in degrees per second.
28079                                 Infotext         string
28080                                 Itemstring       string
28081                                 Glow             int8
28082                                 MaxBreath        uint16  // Player only.
28083                                 EyeHeight        float32 // Player only.
28084                                 ZoomFOV          float32 // in degrees. Player only.
28085                                 UseTextureAlpha  bool
28086                                 DmgTextureMod    Texture // suffix
28087                                 Shaded           bool
28088                                 ShowOnMinimap    bool
28089                                 NametagBG        color.NRGBA
28090                         }))(obj)).Colors)[local338]
28091                         w.Write([]byte{x.A, x.R, x.G, x.B})
28092
28093                 }
28094         }
28095         {
28096                 x := (*(*(struct {
28097                         MaxHP            uint16 // Player only.
28098                         CollideWithNodes bool
28099                         Weight           float32 // deprecated
28100                         ColBox, SelBox   Box
28101                         Pointable        bool
28102                         Visual           string
28103                         VisualSize       [3]float32
28104                         Textures         []Texture
28105                         SpriteSheetSize  [2]int16 // in sprites.
28106                         SpritePos        [2]int16 // in sprite sheet.
28107                         Visible          bool
28108                         MakeFootstepSnds bool
28109                         RotateSpeed      float32 // in radians per second.
28110                         Mesh             string
28111                         Colors           []color.NRGBA
28112                         CollideWithAOs   bool
28113                         StepHeight       float32
28114                         FaceRotateDir    bool
28115                         FaceRotateDirOff float32 // in degrees.
28116                         BackfaceCull     bool
28117                         Nametag          string
28118                         NametagColor     color.NRGBA
28119                         FaceRotateSpeed  float32 // in degrees per second.
28120                         Infotext         string
28121                         Itemstring       string
28122                         Glow             int8
28123                         MaxBreath        uint16  // Player only.
28124                         EyeHeight        float32 // Player only.
28125                         ZoomFOV          float32 // in degrees. Player only.
28126                         UseTextureAlpha  bool
28127                         DmgTextureMod    Texture // suffix
28128                         Shaded           bool
28129                         ShowOnMinimap    bool
28130                         NametagBG        color.NRGBA
28131                 }))(obj)).CollideWithAOs
28132                 if x {
28133                         write8(w, 1)
28134                 } else {
28135                         write8(w, 0)
28136                 }
28137
28138         }
28139         {
28140                 x := (*(*(struct {
28141                         MaxHP            uint16 // Player only.
28142                         CollideWithNodes bool
28143                         Weight           float32 // deprecated
28144                         ColBox, SelBox   Box
28145                         Pointable        bool
28146                         Visual           string
28147                         VisualSize       [3]float32
28148                         Textures         []Texture
28149                         SpriteSheetSize  [2]int16 // in sprites.
28150                         SpritePos        [2]int16 // in sprite sheet.
28151                         Visible          bool
28152                         MakeFootstepSnds bool
28153                         RotateSpeed      float32 // in radians per second.
28154                         Mesh             string
28155                         Colors           []color.NRGBA
28156                         CollideWithAOs   bool
28157                         StepHeight       float32
28158                         FaceRotateDir    bool
28159                         FaceRotateDirOff float32 // in degrees.
28160                         BackfaceCull     bool
28161                         Nametag          string
28162                         NametagColor     color.NRGBA
28163                         FaceRotateSpeed  float32 // in degrees per second.
28164                         Infotext         string
28165                         Itemstring       string
28166                         Glow             int8
28167                         MaxBreath        uint16  // Player only.
28168                         EyeHeight        float32 // Player only.
28169                         ZoomFOV          float32 // in degrees. Player only.
28170                         UseTextureAlpha  bool
28171                         DmgTextureMod    Texture // suffix
28172                         Shaded           bool
28173                         ShowOnMinimap    bool
28174                         NametagBG        color.NRGBA
28175                 }))(obj)).StepHeight
28176                 write32(w, math.Float32bits(x))
28177         }
28178         {
28179                 x := (*(*(struct {
28180                         MaxHP            uint16 // Player only.
28181                         CollideWithNodes bool
28182                         Weight           float32 // deprecated
28183                         ColBox, SelBox   Box
28184                         Pointable        bool
28185                         Visual           string
28186                         VisualSize       [3]float32
28187                         Textures         []Texture
28188                         SpriteSheetSize  [2]int16 // in sprites.
28189                         SpritePos        [2]int16 // in sprite sheet.
28190                         Visible          bool
28191                         MakeFootstepSnds bool
28192                         RotateSpeed      float32 // in radians per second.
28193                         Mesh             string
28194                         Colors           []color.NRGBA
28195                         CollideWithAOs   bool
28196                         StepHeight       float32
28197                         FaceRotateDir    bool
28198                         FaceRotateDirOff float32 // in degrees.
28199                         BackfaceCull     bool
28200                         Nametag          string
28201                         NametagColor     color.NRGBA
28202                         FaceRotateSpeed  float32 // in degrees per second.
28203                         Infotext         string
28204                         Itemstring       string
28205                         Glow             int8
28206                         MaxBreath        uint16  // Player only.
28207                         EyeHeight        float32 // Player only.
28208                         ZoomFOV          float32 // in degrees. Player only.
28209                         UseTextureAlpha  bool
28210                         DmgTextureMod    Texture // suffix
28211                         Shaded           bool
28212                         ShowOnMinimap    bool
28213                         NametagBG        color.NRGBA
28214                 }))(obj)).FaceRotateDir
28215                 if x {
28216                         write8(w, 1)
28217                 } else {
28218                         write8(w, 0)
28219                 }
28220
28221         }
28222         {
28223                 x := (*(*(struct {
28224                         MaxHP            uint16 // Player only.
28225                         CollideWithNodes bool
28226                         Weight           float32 // deprecated
28227                         ColBox, SelBox   Box
28228                         Pointable        bool
28229                         Visual           string
28230                         VisualSize       [3]float32
28231                         Textures         []Texture
28232                         SpriteSheetSize  [2]int16 // in sprites.
28233                         SpritePos        [2]int16 // in sprite sheet.
28234                         Visible          bool
28235                         MakeFootstepSnds bool
28236                         RotateSpeed      float32 // in radians per second.
28237                         Mesh             string
28238                         Colors           []color.NRGBA
28239                         CollideWithAOs   bool
28240                         StepHeight       float32
28241                         FaceRotateDir    bool
28242                         FaceRotateDirOff float32 // in degrees.
28243                         BackfaceCull     bool
28244                         Nametag          string
28245                         NametagColor     color.NRGBA
28246                         FaceRotateSpeed  float32 // in degrees per second.
28247                         Infotext         string
28248                         Itemstring       string
28249                         Glow             int8
28250                         MaxBreath        uint16  // Player only.
28251                         EyeHeight        float32 // Player only.
28252                         ZoomFOV          float32 // in degrees. Player only.
28253                         UseTextureAlpha  bool
28254                         DmgTextureMod    Texture // suffix
28255                         Shaded           bool
28256                         ShowOnMinimap    bool
28257                         NametagBG        color.NRGBA
28258                 }))(obj)).FaceRotateDirOff
28259                 write32(w, math.Float32bits(x))
28260         }
28261         {
28262                 x := (*(*(struct {
28263                         MaxHP            uint16 // Player only.
28264                         CollideWithNodes bool
28265                         Weight           float32 // deprecated
28266                         ColBox, SelBox   Box
28267                         Pointable        bool
28268                         Visual           string
28269                         VisualSize       [3]float32
28270                         Textures         []Texture
28271                         SpriteSheetSize  [2]int16 // in sprites.
28272                         SpritePos        [2]int16 // in sprite sheet.
28273                         Visible          bool
28274                         MakeFootstepSnds bool
28275                         RotateSpeed      float32 // in radians per second.
28276                         Mesh             string
28277                         Colors           []color.NRGBA
28278                         CollideWithAOs   bool
28279                         StepHeight       float32
28280                         FaceRotateDir    bool
28281                         FaceRotateDirOff float32 // in degrees.
28282                         BackfaceCull     bool
28283                         Nametag          string
28284                         NametagColor     color.NRGBA
28285                         FaceRotateSpeed  float32 // in degrees per second.
28286                         Infotext         string
28287                         Itemstring       string
28288                         Glow             int8
28289                         MaxBreath        uint16  // Player only.
28290                         EyeHeight        float32 // Player only.
28291                         ZoomFOV          float32 // in degrees. Player only.
28292                         UseTextureAlpha  bool
28293                         DmgTextureMod    Texture // suffix
28294                         Shaded           bool
28295                         ShowOnMinimap    bool
28296                         NametagBG        color.NRGBA
28297                 }))(obj)).BackfaceCull
28298                 if x {
28299                         write8(w, 1)
28300                 } else {
28301                         write8(w, 0)
28302                 }
28303
28304         }
28305         if len(([]byte((*(*(struct {
28306                 MaxHP            uint16 // Player only.
28307                 CollideWithNodes bool
28308                 Weight           float32 // deprecated
28309                 ColBox, SelBox   Box
28310                 Pointable        bool
28311                 Visual           string
28312                 VisualSize       [3]float32
28313                 Textures         []Texture
28314                 SpriteSheetSize  [2]int16 // in sprites.
28315                 SpritePos        [2]int16 // in sprite sheet.
28316                 Visible          bool
28317                 MakeFootstepSnds bool
28318                 RotateSpeed      float32 // in radians per second.
28319                 Mesh             string
28320                 Colors           []color.NRGBA
28321                 CollideWithAOs   bool
28322                 StepHeight       float32
28323                 FaceRotateDir    bool
28324                 FaceRotateDirOff float32 // in degrees.
28325                 BackfaceCull     bool
28326                 Nametag          string
28327                 NametagColor     color.NRGBA
28328                 FaceRotateSpeed  float32 // in degrees per second.
28329                 Infotext         string
28330                 Itemstring       string
28331                 Glow             int8
28332                 MaxBreath        uint16  // Player only.
28333                 EyeHeight        float32 // Player only.
28334                 ZoomFOV          float32 // in degrees. Player only.
28335                 UseTextureAlpha  bool
28336                 DmgTextureMod    Texture // suffix
28337                 Shaded           bool
28338                 ShowOnMinimap    bool
28339                 NametagBG        color.NRGBA
28340         }))(obj)).Nametag))) > math.MaxUint16 {
28341                 chk(ErrTooLong)
28342         }
28343         {
28344                 x := uint16(len(([]byte((*(*(struct {
28345                         MaxHP            uint16 // Player only.
28346                         CollideWithNodes bool
28347                         Weight           float32 // deprecated
28348                         ColBox, SelBox   Box
28349                         Pointable        bool
28350                         Visual           string
28351                         VisualSize       [3]float32
28352                         Textures         []Texture
28353                         SpriteSheetSize  [2]int16 // in sprites.
28354                         SpritePos        [2]int16 // in sprite sheet.
28355                         Visible          bool
28356                         MakeFootstepSnds bool
28357                         RotateSpeed      float32 // in radians per second.
28358                         Mesh             string
28359                         Colors           []color.NRGBA
28360                         CollideWithAOs   bool
28361                         StepHeight       float32
28362                         FaceRotateDir    bool
28363                         FaceRotateDirOff float32 // in degrees.
28364                         BackfaceCull     bool
28365                         Nametag          string
28366                         NametagColor     color.NRGBA
28367                         FaceRotateSpeed  float32 // in degrees per second.
28368                         Infotext         string
28369                         Itemstring       string
28370                         Glow             int8
28371                         MaxBreath        uint16  // Player only.
28372                         EyeHeight        float32 // Player only.
28373                         ZoomFOV          float32 // in degrees. Player only.
28374                         UseTextureAlpha  bool
28375                         DmgTextureMod    Texture // suffix
28376                         Shaded           bool
28377                         ShowOnMinimap    bool
28378                         NametagBG        color.NRGBA
28379                 }))(obj)).Nametag))))
28380                 write16(w, uint16(x))
28381         }
28382         {
28383                 _, err := w.Write(([]byte((*(*(struct {
28384                         MaxHP            uint16 // Player only.
28385                         CollideWithNodes bool
28386                         Weight           float32 // deprecated
28387                         ColBox, SelBox   Box
28388                         Pointable        bool
28389                         Visual           string
28390                         VisualSize       [3]float32
28391                         Textures         []Texture
28392                         SpriteSheetSize  [2]int16 // in sprites.
28393                         SpritePos        [2]int16 // in sprite sheet.
28394                         Visible          bool
28395                         MakeFootstepSnds bool
28396                         RotateSpeed      float32 // in radians per second.
28397                         Mesh             string
28398                         Colors           []color.NRGBA
28399                         CollideWithAOs   bool
28400                         StepHeight       float32
28401                         FaceRotateDir    bool
28402                         FaceRotateDirOff float32 // in degrees.
28403                         BackfaceCull     bool
28404                         Nametag          string
28405                         NametagColor     color.NRGBA
28406                         FaceRotateSpeed  float32 // in degrees per second.
28407                         Infotext         string
28408                         Itemstring       string
28409                         Glow             int8
28410                         MaxBreath        uint16  // Player only.
28411                         EyeHeight        float32 // Player only.
28412                         ZoomFOV          float32 // in degrees. Player only.
28413                         UseTextureAlpha  bool
28414                         DmgTextureMod    Texture // suffix
28415                         Shaded           bool
28416                         ShowOnMinimap    bool
28417                         NametagBG        color.NRGBA
28418                 }))(obj)).Nametag))[:])
28419                 chk(err)
28420         }
28421         {
28422                 x := (*(*(struct {
28423                         MaxHP            uint16 // Player only.
28424                         CollideWithNodes bool
28425                         Weight           float32 // deprecated
28426                         ColBox, SelBox   Box
28427                         Pointable        bool
28428                         Visual           string
28429                         VisualSize       [3]float32
28430                         Textures         []Texture
28431                         SpriteSheetSize  [2]int16 // in sprites.
28432                         SpritePos        [2]int16 // in sprite sheet.
28433                         Visible          bool
28434                         MakeFootstepSnds bool
28435                         RotateSpeed      float32 // in radians per second.
28436                         Mesh             string
28437                         Colors           []color.NRGBA
28438                         CollideWithAOs   bool
28439                         StepHeight       float32
28440                         FaceRotateDir    bool
28441                         FaceRotateDirOff float32 // in degrees.
28442                         BackfaceCull     bool
28443                         Nametag          string
28444                         NametagColor     color.NRGBA
28445                         FaceRotateSpeed  float32 // in degrees per second.
28446                         Infotext         string
28447                         Itemstring       string
28448                         Glow             int8
28449                         MaxBreath        uint16  // Player only.
28450                         EyeHeight        float32 // Player only.
28451                         ZoomFOV          float32 // in degrees. Player only.
28452                         UseTextureAlpha  bool
28453                         DmgTextureMod    Texture // suffix
28454                         Shaded           bool
28455                         ShowOnMinimap    bool
28456                         NametagBG        color.NRGBA
28457                 }))(obj)).NametagColor
28458                 w.Write([]byte{x.A, x.R, x.G, x.B})
28459
28460         }
28461         {
28462                 x := (*(*(struct {
28463                         MaxHP            uint16 // Player only.
28464                         CollideWithNodes bool
28465                         Weight           float32 // deprecated
28466                         ColBox, SelBox   Box
28467                         Pointable        bool
28468                         Visual           string
28469                         VisualSize       [3]float32
28470                         Textures         []Texture
28471                         SpriteSheetSize  [2]int16 // in sprites.
28472                         SpritePos        [2]int16 // in sprite sheet.
28473                         Visible          bool
28474                         MakeFootstepSnds bool
28475                         RotateSpeed      float32 // in radians per second.
28476                         Mesh             string
28477                         Colors           []color.NRGBA
28478                         CollideWithAOs   bool
28479                         StepHeight       float32
28480                         FaceRotateDir    bool
28481                         FaceRotateDirOff float32 // in degrees.
28482                         BackfaceCull     bool
28483                         Nametag          string
28484                         NametagColor     color.NRGBA
28485                         FaceRotateSpeed  float32 // in degrees per second.
28486                         Infotext         string
28487                         Itemstring       string
28488                         Glow             int8
28489                         MaxBreath        uint16  // Player only.
28490                         EyeHeight        float32 // Player only.
28491                         ZoomFOV          float32 // in degrees. Player only.
28492                         UseTextureAlpha  bool
28493                         DmgTextureMod    Texture // suffix
28494                         Shaded           bool
28495                         ShowOnMinimap    bool
28496                         NametagBG        color.NRGBA
28497                 }))(obj)).FaceRotateSpeed
28498                 write32(w, math.Float32bits(x))
28499         }
28500         if len(([]byte((*(*(struct {
28501                 MaxHP            uint16 // Player only.
28502                 CollideWithNodes bool
28503                 Weight           float32 // deprecated
28504                 ColBox, SelBox   Box
28505                 Pointable        bool
28506                 Visual           string
28507                 VisualSize       [3]float32
28508                 Textures         []Texture
28509                 SpriteSheetSize  [2]int16 // in sprites.
28510                 SpritePos        [2]int16 // in sprite sheet.
28511                 Visible          bool
28512                 MakeFootstepSnds bool
28513                 RotateSpeed      float32 // in radians per second.
28514                 Mesh             string
28515                 Colors           []color.NRGBA
28516                 CollideWithAOs   bool
28517                 StepHeight       float32
28518                 FaceRotateDir    bool
28519                 FaceRotateDirOff float32 // in degrees.
28520                 BackfaceCull     bool
28521                 Nametag          string
28522                 NametagColor     color.NRGBA
28523                 FaceRotateSpeed  float32 // in degrees per second.
28524                 Infotext         string
28525                 Itemstring       string
28526                 Glow             int8
28527                 MaxBreath        uint16  // Player only.
28528                 EyeHeight        float32 // Player only.
28529                 ZoomFOV          float32 // in degrees. Player only.
28530                 UseTextureAlpha  bool
28531                 DmgTextureMod    Texture // suffix
28532                 Shaded           bool
28533                 ShowOnMinimap    bool
28534                 NametagBG        color.NRGBA
28535         }))(obj)).Infotext))) > math.MaxUint16 {
28536                 chk(ErrTooLong)
28537         }
28538         {
28539                 x := uint16(len(([]byte((*(*(struct {
28540                         MaxHP            uint16 // Player only.
28541                         CollideWithNodes bool
28542                         Weight           float32 // deprecated
28543                         ColBox, SelBox   Box
28544                         Pointable        bool
28545                         Visual           string
28546                         VisualSize       [3]float32
28547                         Textures         []Texture
28548                         SpriteSheetSize  [2]int16 // in sprites.
28549                         SpritePos        [2]int16 // in sprite sheet.
28550                         Visible          bool
28551                         MakeFootstepSnds bool
28552                         RotateSpeed      float32 // in radians per second.
28553                         Mesh             string
28554                         Colors           []color.NRGBA
28555                         CollideWithAOs   bool
28556                         StepHeight       float32
28557                         FaceRotateDir    bool
28558                         FaceRotateDirOff float32 // in degrees.
28559                         BackfaceCull     bool
28560                         Nametag          string
28561                         NametagColor     color.NRGBA
28562                         FaceRotateSpeed  float32 // in degrees per second.
28563                         Infotext         string
28564                         Itemstring       string
28565                         Glow             int8
28566                         MaxBreath        uint16  // Player only.
28567                         EyeHeight        float32 // Player only.
28568                         ZoomFOV          float32 // in degrees. Player only.
28569                         UseTextureAlpha  bool
28570                         DmgTextureMod    Texture // suffix
28571                         Shaded           bool
28572                         ShowOnMinimap    bool
28573                         NametagBG        color.NRGBA
28574                 }))(obj)).Infotext))))
28575                 write16(w, uint16(x))
28576         }
28577         {
28578                 _, err := w.Write(([]byte((*(*(struct {
28579                         MaxHP            uint16 // Player only.
28580                         CollideWithNodes bool
28581                         Weight           float32 // deprecated
28582                         ColBox, SelBox   Box
28583                         Pointable        bool
28584                         Visual           string
28585                         VisualSize       [3]float32
28586                         Textures         []Texture
28587                         SpriteSheetSize  [2]int16 // in sprites.
28588                         SpritePos        [2]int16 // in sprite sheet.
28589                         Visible          bool
28590                         MakeFootstepSnds bool
28591                         RotateSpeed      float32 // in radians per second.
28592                         Mesh             string
28593                         Colors           []color.NRGBA
28594                         CollideWithAOs   bool
28595                         StepHeight       float32
28596                         FaceRotateDir    bool
28597                         FaceRotateDirOff float32 // in degrees.
28598                         BackfaceCull     bool
28599                         Nametag          string
28600                         NametagColor     color.NRGBA
28601                         FaceRotateSpeed  float32 // in degrees per second.
28602                         Infotext         string
28603                         Itemstring       string
28604                         Glow             int8
28605                         MaxBreath        uint16  // Player only.
28606                         EyeHeight        float32 // Player only.
28607                         ZoomFOV          float32 // in degrees. Player only.
28608                         UseTextureAlpha  bool
28609                         DmgTextureMod    Texture // suffix
28610                         Shaded           bool
28611                         ShowOnMinimap    bool
28612                         NametagBG        color.NRGBA
28613                 }))(obj)).Infotext))[:])
28614                 chk(err)
28615         }
28616         if len(([]byte((*(*(struct {
28617                 MaxHP            uint16 // Player only.
28618                 CollideWithNodes bool
28619                 Weight           float32 // deprecated
28620                 ColBox, SelBox   Box
28621                 Pointable        bool
28622                 Visual           string
28623                 VisualSize       [3]float32
28624                 Textures         []Texture
28625                 SpriteSheetSize  [2]int16 // in sprites.
28626                 SpritePos        [2]int16 // in sprite sheet.
28627                 Visible          bool
28628                 MakeFootstepSnds bool
28629                 RotateSpeed      float32 // in radians per second.
28630                 Mesh             string
28631                 Colors           []color.NRGBA
28632                 CollideWithAOs   bool
28633                 StepHeight       float32
28634                 FaceRotateDir    bool
28635                 FaceRotateDirOff float32 // in degrees.
28636                 BackfaceCull     bool
28637                 Nametag          string
28638                 NametagColor     color.NRGBA
28639                 FaceRotateSpeed  float32 // in degrees per second.
28640                 Infotext         string
28641                 Itemstring       string
28642                 Glow             int8
28643                 MaxBreath        uint16  // Player only.
28644                 EyeHeight        float32 // Player only.
28645                 ZoomFOV          float32 // in degrees. Player only.
28646                 UseTextureAlpha  bool
28647                 DmgTextureMod    Texture // suffix
28648                 Shaded           bool
28649                 ShowOnMinimap    bool
28650                 NametagBG        color.NRGBA
28651         }))(obj)).Itemstring))) > math.MaxUint16 {
28652                 chk(ErrTooLong)
28653         }
28654         {
28655                 x := uint16(len(([]byte((*(*(struct {
28656                         MaxHP            uint16 // Player only.
28657                         CollideWithNodes bool
28658                         Weight           float32 // deprecated
28659                         ColBox, SelBox   Box
28660                         Pointable        bool
28661                         Visual           string
28662                         VisualSize       [3]float32
28663                         Textures         []Texture
28664                         SpriteSheetSize  [2]int16 // in sprites.
28665                         SpritePos        [2]int16 // in sprite sheet.
28666                         Visible          bool
28667                         MakeFootstepSnds bool
28668                         RotateSpeed      float32 // in radians per second.
28669                         Mesh             string
28670                         Colors           []color.NRGBA
28671                         CollideWithAOs   bool
28672                         StepHeight       float32
28673                         FaceRotateDir    bool
28674                         FaceRotateDirOff float32 // in degrees.
28675                         BackfaceCull     bool
28676                         Nametag          string
28677                         NametagColor     color.NRGBA
28678                         FaceRotateSpeed  float32 // in degrees per second.
28679                         Infotext         string
28680                         Itemstring       string
28681                         Glow             int8
28682                         MaxBreath        uint16  // Player only.
28683                         EyeHeight        float32 // Player only.
28684                         ZoomFOV          float32 // in degrees. Player only.
28685                         UseTextureAlpha  bool
28686                         DmgTextureMod    Texture // suffix
28687                         Shaded           bool
28688                         ShowOnMinimap    bool
28689                         NametagBG        color.NRGBA
28690                 }))(obj)).Itemstring))))
28691                 write16(w, uint16(x))
28692         }
28693         {
28694                 _, err := w.Write(([]byte((*(*(struct {
28695                         MaxHP            uint16 // Player only.
28696                         CollideWithNodes bool
28697                         Weight           float32 // deprecated
28698                         ColBox, SelBox   Box
28699                         Pointable        bool
28700                         Visual           string
28701                         VisualSize       [3]float32
28702                         Textures         []Texture
28703                         SpriteSheetSize  [2]int16 // in sprites.
28704                         SpritePos        [2]int16 // in sprite sheet.
28705                         Visible          bool
28706                         MakeFootstepSnds bool
28707                         RotateSpeed      float32 // in radians per second.
28708                         Mesh             string
28709                         Colors           []color.NRGBA
28710                         CollideWithAOs   bool
28711                         StepHeight       float32
28712                         FaceRotateDir    bool
28713                         FaceRotateDirOff float32 // in degrees.
28714                         BackfaceCull     bool
28715                         Nametag          string
28716                         NametagColor     color.NRGBA
28717                         FaceRotateSpeed  float32 // in degrees per second.
28718                         Infotext         string
28719                         Itemstring       string
28720                         Glow             int8
28721                         MaxBreath        uint16  // Player only.
28722                         EyeHeight        float32 // Player only.
28723                         ZoomFOV          float32 // in degrees. Player only.
28724                         UseTextureAlpha  bool
28725                         DmgTextureMod    Texture // suffix
28726                         Shaded           bool
28727                         ShowOnMinimap    bool
28728                         NametagBG        color.NRGBA
28729                 }))(obj)).Itemstring))[:])
28730                 chk(err)
28731         }
28732         {
28733                 x := (*(*(struct {
28734                         MaxHP            uint16 // Player only.
28735                         CollideWithNodes bool
28736                         Weight           float32 // deprecated
28737                         ColBox, SelBox   Box
28738                         Pointable        bool
28739                         Visual           string
28740                         VisualSize       [3]float32
28741                         Textures         []Texture
28742                         SpriteSheetSize  [2]int16 // in sprites.
28743                         SpritePos        [2]int16 // in sprite sheet.
28744                         Visible          bool
28745                         MakeFootstepSnds bool
28746                         RotateSpeed      float32 // in radians per second.
28747                         Mesh             string
28748                         Colors           []color.NRGBA
28749                         CollideWithAOs   bool
28750                         StepHeight       float32
28751                         FaceRotateDir    bool
28752                         FaceRotateDirOff float32 // in degrees.
28753                         BackfaceCull     bool
28754                         Nametag          string
28755                         NametagColor     color.NRGBA
28756                         FaceRotateSpeed  float32 // in degrees per second.
28757                         Infotext         string
28758                         Itemstring       string
28759                         Glow             int8
28760                         MaxBreath        uint16  // Player only.
28761                         EyeHeight        float32 // Player only.
28762                         ZoomFOV          float32 // in degrees. Player only.
28763                         UseTextureAlpha  bool
28764                         DmgTextureMod    Texture // suffix
28765                         Shaded           bool
28766                         ShowOnMinimap    bool
28767                         NametagBG        color.NRGBA
28768                 }))(obj)).Glow
28769                 write8(w, uint8(x))
28770         }
28771         {
28772                 x := (*(*(struct {
28773                         MaxHP            uint16 // Player only.
28774                         CollideWithNodes bool
28775                         Weight           float32 // deprecated
28776                         ColBox, SelBox   Box
28777                         Pointable        bool
28778                         Visual           string
28779                         VisualSize       [3]float32
28780                         Textures         []Texture
28781                         SpriteSheetSize  [2]int16 // in sprites.
28782                         SpritePos        [2]int16 // in sprite sheet.
28783                         Visible          bool
28784                         MakeFootstepSnds bool
28785                         RotateSpeed      float32 // in radians per second.
28786                         Mesh             string
28787                         Colors           []color.NRGBA
28788                         CollideWithAOs   bool
28789                         StepHeight       float32
28790                         FaceRotateDir    bool
28791                         FaceRotateDirOff float32 // in degrees.
28792                         BackfaceCull     bool
28793                         Nametag          string
28794                         NametagColor     color.NRGBA
28795                         FaceRotateSpeed  float32 // in degrees per second.
28796                         Infotext         string
28797                         Itemstring       string
28798                         Glow             int8
28799                         MaxBreath        uint16  // Player only.
28800                         EyeHeight        float32 // Player only.
28801                         ZoomFOV          float32 // in degrees. Player only.
28802                         UseTextureAlpha  bool
28803                         DmgTextureMod    Texture // suffix
28804                         Shaded           bool
28805                         ShowOnMinimap    bool
28806                         NametagBG        color.NRGBA
28807                 }))(obj)).MaxBreath
28808                 write16(w, uint16(x))
28809         }
28810         {
28811                 x := (*(*(struct {
28812                         MaxHP            uint16 // Player only.
28813                         CollideWithNodes bool
28814                         Weight           float32 // deprecated
28815                         ColBox, SelBox   Box
28816                         Pointable        bool
28817                         Visual           string
28818                         VisualSize       [3]float32
28819                         Textures         []Texture
28820                         SpriteSheetSize  [2]int16 // in sprites.
28821                         SpritePos        [2]int16 // in sprite sheet.
28822                         Visible          bool
28823                         MakeFootstepSnds bool
28824                         RotateSpeed      float32 // in radians per second.
28825                         Mesh             string
28826                         Colors           []color.NRGBA
28827                         CollideWithAOs   bool
28828                         StepHeight       float32
28829                         FaceRotateDir    bool
28830                         FaceRotateDirOff float32 // in degrees.
28831                         BackfaceCull     bool
28832                         Nametag          string
28833                         NametagColor     color.NRGBA
28834                         FaceRotateSpeed  float32 // in degrees per second.
28835                         Infotext         string
28836                         Itemstring       string
28837                         Glow             int8
28838                         MaxBreath        uint16  // Player only.
28839                         EyeHeight        float32 // Player only.
28840                         ZoomFOV          float32 // in degrees. Player only.
28841                         UseTextureAlpha  bool
28842                         DmgTextureMod    Texture // suffix
28843                         Shaded           bool
28844                         ShowOnMinimap    bool
28845                         NametagBG        color.NRGBA
28846                 }))(obj)).EyeHeight
28847                 write32(w, math.Float32bits(x))
28848         }
28849         {
28850                 x := (*(*(struct {
28851                         MaxHP            uint16 // Player only.
28852                         CollideWithNodes bool
28853                         Weight           float32 // deprecated
28854                         ColBox, SelBox   Box
28855                         Pointable        bool
28856                         Visual           string
28857                         VisualSize       [3]float32
28858                         Textures         []Texture
28859                         SpriteSheetSize  [2]int16 // in sprites.
28860                         SpritePos        [2]int16 // in sprite sheet.
28861                         Visible          bool
28862                         MakeFootstepSnds bool
28863                         RotateSpeed      float32 // in radians per second.
28864                         Mesh             string
28865                         Colors           []color.NRGBA
28866                         CollideWithAOs   bool
28867                         StepHeight       float32
28868                         FaceRotateDir    bool
28869                         FaceRotateDirOff float32 // in degrees.
28870                         BackfaceCull     bool
28871                         Nametag          string
28872                         NametagColor     color.NRGBA
28873                         FaceRotateSpeed  float32 // in degrees per second.
28874                         Infotext         string
28875                         Itemstring       string
28876                         Glow             int8
28877                         MaxBreath        uint16  // Player only.
28878                         EyeHeight        float32 // Player only.
28879                         ZoomFOV          float32 // in degrees. Player only.
28880                         UseTextureAlpha  bool
28881                         DmgTextureMod    Texture // suffix
28882                         Shaded           bool
28883                         ShowOnMinimap    bool
28884                         NametagBG        color.NRGBA
28885                 }))(obj)).ZoomFOV
28886                 write32(w, math.Float32bits(x))
28887         }
28888         {
28889                 x := (*(*(struct {
28890                         MaxHP            uint16 // Player only.
28891                         CollideWithNodes bool
28892                         Weight           float32 // deprecated
28893                         ColBox, SelBox   Box
28894                         Pointable        bool
28895                         Visual           string
28896                         VisualSize       [3]float32
28897                         Textures         []Texture
28898                         SpriteSheetSize  [2]int16 // in sprites.
28899                         SpritePos        [2]int16 // in sprite sheet.
28900                         Visible          bool
28901                         MakeFootstepSnds bool
28902                         RotateSpeed      float32 // in radians per second.
28903                         Mesh             string
28904                         Colors           []color.NRGBA
28905                         CollideWithAOs   bool
28906                         StepHeight       float32
28907                         FaceRotateDir    bool
28908                         FaceRotateDirOff float32 // in degrees.
28909                         BackfaceCull     bool
28910                         Nametag          string
28911                         NametagColor     color.NRGBA
28912                         FaceRotateSpeed  float32 // in degrees per second.
28913                         Infotext         string
28914                         Itemstring       string
28915                         Glow             int8
28916                         MaxBreath        uint16  // Player only.
28917                         EyeHeight        float32 // Player only.
28918                         ZoomFOV          float32 // in degrees. Player only.
28919                         UseTextureAlpha  bool
28920                         DmgTextureMod    Texture // suffix
28921                         Shaded           bool
28922                         ShowOnMinimap    bool
28923                         NametagBG        color.NRGBA
28924                 }))(obj)).UseTextureAlpha
28925                 if x {
28926                         write8(w, 1)
28927                 } else {
28928                         write8(w, 0)
28929                 }
28930
28931         }
28932         if err := pcall(func() {
28933                 ((*(*(struct {
28934                         MaxHP            uint16 // Player only.
28935                         CollideWithNodes bool
28936                         Weight           float32 // deprecated
28937                         ColBox, SelBox   Box
28938                         Pointable        bool
28939                         Visual           string
28940                         VisualSize       [3]float32
28941                         Textures         []Texture
28942                         SpriteSheetSize  [2]int16 // in sprites.
28943                         SpritePos        [2]int16 // in sprite sheet.
28944                         Visible          bool
28945                         MakeFootstepSnds bool
28946                         RotateSpeed      float32 // in radians per second.
28947                         Mesh             string
28948                         Colors           []color.NRGBA
28949                         CollideWithAOs   bool
28950                         StepHeight       float32
28951                         FaceRotateDir    bool
28952                         FaceRotateDirOff float32 // in degrees.
28953                         BackfaceCull     bool
28954                         Nametag          string
28955                         NametagColor     color.NRGBA
28956                         FaceRotateSpeed  float32 // in degrees per second.
28957                         Infotext         string
28958                         Itemstring       string
28959                         Glow             int8
28960                         MaxBreath        uint16  // Player only.
28961                         EyeHeight        float32 // Player only.
28962                         ZoomFOV          float32 // in degrees. Player only.
28963                         UseTextureAlpha  bool
28964                         DmgTextureMod    Texture // suffix
28965                         Shaded           bool
28966                         ShowOnMinimap    bool
28967                         NametagBG        color.NRGBA
28968                 }))(obj)).DmgTextureMod).serialize(w)
28969         }); err != nil {
28970                 if err == io.EOF {
28971                         chk(io.EOF)
28972                 }
28973                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
28974         }
28975         {
28976                 x := (*(*(struct {
28977                         MaxHP            uint16 // Player only.
28978                         CollideWithNodes bool
28979                         Weight           float32 // deprecated
28980                         ColBox, SelBox   Box
28981                         Pointable        bool
28982                         Visual           string
28983                         VisualSize       [3]float32
28984                         Textures         []Texture
28985                         SpriteSheetSize  [2]int16 // in sprites.
28986                         SpritePos        [2]int16 // in sprite sheet.
28987                         Visible          bool
28988                         MakeFootstepSnds bool
28989                         RotateSpeed      float32 // in radians per second.
28990                         Mesh             string
28991                         Colors           []color.NRGBA
28992                         CollideWithAOs   bool
28993                         StepHeight       float32
28994                         FaceRotateDir    bool
28995                         FaceRotateDirOff float32 // in degrees.
28996                         BackfaceCull     bool
28997                         Nametag          string
28998                         NametagColor     color.NRGBA
28999                         FaceRotateSpeed  float32 // in degrees per second.
29000                         Infotext         string
29001                         Itemstring       string
29002                         Glow             int8
29003                         MaxBreath        uint16  // Player only.
29004                         EyeHeight        float32 // Player only.
29005                         ZoomFOV          float32 // in degrees. Player only.
29006                         UseTextureAlpha  bool
29007                         DmgTextureMod    Texture // suffix
29008                         Shaded           bool
29009                         ShowOnMinimap    bool
29010                         NametagBG        color.NRGBA
29011                 }))(obj)).Shaded
29012                 if x {
29013                         write8(w, 1)
29014                 } else {
29015                         write8(w, 0)
29016                 }
29017
29018         }
29019         {
29020                 x := (*(*(struct {
29021                         MaxHP            uint16 // Player only.
29022                         CollideWithNodes bool
29023                         Weight           float32 // deprecated
29024                         ColBox, SelBox   Box
29025                         Pointable        bool
29026                         Visual           string
29027                         VisualSize       [3]float32
29028                         Textures         []Texture
29029                         SpriteSheetSize  [2]int16 // in sprites.
29030                         SpritePos        [2]int16 // in sprite sheet.
29031                         Visible          bool
29032                         MakeFootstepSnds bool
29033                         RotateSpeed      float32 // in radians per second.
29034                         Mesh             string
29035                         Colors           []color.NRGBA
29036                         CollideWithAOs   bool
29037                         StepHeight       float32
29038                         FaceRotateDir    bool
29039                         FaceRotateDirOff float32 // in degrees.
29040                         BackfaceCull     bool
29041                         Nametag          string
29042                         NametagColor     color.NRGBA
29043                         FaceRotateSpeed  float32 // in degrees per second.
29044                         Infotext         string
29045                         Itemstring       string
29046                         Glow             int8
29047                         MaxBreath        uint16  // Player only.
29048                         EyeHeight        float32 // Player only.
29049                         ZoomFOV          float32 // in degrees. Player only.
29050                         UseTextureAlpha  bool
29051                         DmgTextureMod    Texture // suffix
29052                         Shaded           bool
29053                         ShowOnMinimap    bool
29054                         NametagBG        color.NRGBA
29055                 }))(obj)).ShowOnMinimap
29056                 if x {
29057                         write8(w, 1)
29058                 } else {
29059                         write8(w, 0)
29060                 }
29061
29062         }
29063         {
29064                 x := (*(*(struct {
29065                         MaxHP            uint16 // Player only.
29066                         CollideWithNodes bool
29067                         Weight           float32 // deprecated
29068                         ColBox, SelBox   Box
29069                         Pointable        bool
29070                         Visual           string
29071                         VisualSize       [3]float32
29072                         Textures         []Texture
29073                         SpriteSheetSize  [2]int16 // in sprites.
29074                         SpritePos        [2]int16 // in sprite sheet.
29075                         Visible          bool
29076                         MakeFootstepSnds bool
29077                         RotateSpeed      float32 // in radians per second.
29078                         Mesh             string
29079                         Colors           []color.NRGBA
29080                         CollideWithAOs   bool
29081                         StepHeight       float32
29082                         FaceRotateDir    bool
29083                         FaceRotateDirOff float32 // in degrees.
29084                         BackfaceCull     bool
29085                         Nametag          string
29086                         NametagColor     color.NRGBA
29087                         FaceRotateSpeed  float32 // in degrees per second.
29088                         Infotext         string
29089                         Itemstring       string
29090                         Glow             int8
29091                         MaxBreath        uint16  // Player only.
29092                         EyeHeight        float32 // Player only.
29093                         ZoomFOV          float32 // in degrees. Player only.
29094                         UseTextureAlpha  bool
29095                         DmgTextureMod    Texture // suffix
29096                         Shaded           bool
29097                         ShowOnMinimap    bool
29098                         NametagBG        color.NRGBA
29099                 }))(obj)).NametagBG
29100                 w.Write([]byte{x.A, x.R, x.G, x.B})
29101
29102         }
29103 }
29104
29105 func (obj *AOProps) deserialize(r io.Reader) {
29106         {
29107                 var local339 uint8
29108                 local340 := uint8(4)
29109                 {
29110                         p := &local339
29111                         *p = read8(r)
29112                 }
29113                 if local339 != local340 {
29114                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local339))
29115                 }
29116         }
29117         {
29118                 p := &(*(*(struct {
29119                         MaxHP            uint16 // Player only.
29120                         CollideWithNodes bool
29121                         Weight           float32 // deprecated
29122                         ColBox, SelBox   Box
29123                         Pointable        bool
29124                         Visual           string
29125                         VisualSize       [3]float32
29126                         Textures         []Texture
29127                         SpriteSheetSize  [2]int16 // in sprites.
29128                         SpritePos        [2]int16 // in sprite sheet.
29129                         Visible          bool
29130                         MakeFootstepSnds bool
29131                         RotateSpeed      float32 // in radians per second.
29132                         Mesh             string
29133                         Colors           []color.NRGBA
29134                         CollideWithAOs   bool
29135                         StepHeight       float32
29136                         FaceRotateDir    bool
29137                         FaceRotateDirOff float32 // in degrees.
29138                         BackfaceCull     bool
29139                         Nametag          string
29140                         NametagColor     color.NRGBA
29141                         FaceRotateSpeed  float32 // in degrees per second.
29142                         Infotext         string
29143                         Itemstring       string
29144                         Glow             int8
29145                         MaxBreath        uint16  // Player only.
29146                         EyeHeight        float32 // Player only.
29147                         ZoomFOV          float32 // in degrees. Player only.
29148                         UseTextureAlpha  bool
29149                         DmgTextureMod    Texture // suffix
29150                         Shaded           bool
29151                         ShowOnMinimap    bool
29152                         NametagBG        color.NRGBA
29153                 }))(obj)).MaxHP
29154                 *p = read16(r)
29155         }
29156         {
29157                 p := &(*(*(struct {
29158                         MaxHP            uint16 // Player only.
29159                         CollideWithNodes bool
29160                         Weight           float32 // deprecated
29161                         ColBox, SelBox   Box
29162                         Pointable        bool
29163                         Visual           string
29164                         VisualSize       [3]float32
29165                         Textures         []Texture
29166                         SpriteSheetSize  [2]int16 // in sprites.
29167                         SpritePos        [2]int16 // in sprite sheet.
29168                         Visible          bool
29169                         MakeFootstepSnds bool
29170                         RotateSpeed      float32 // in radians per second.
29171                         Mesh             string
29172                         Colors           []color.NRGBA
29173                         CollideWithAOs   bool
29174                         StepHeight       float32
29175                         FaceRotateDir    bool
29176                         FaceRotateDirOff float32 // in degrees.
29177                         BackfaceCull     bool
29178                         Nametag          string
29179                         NametagColor     color.NRGBA
29180                         FaceRotateSpeed  float32 // in degrees per second.
29181                         Infotext         string
29182                         Itemstring       string
29183                         Glow             int8
29184                         MaxBreath        uint16  // Player only.
29185                         EyeHeight        float32 // Player only.
29186                         ZoomFOV          float32 // in degrees. Player only.
29187                         UseTextureAlpha  bool
29188                         DmgTextureMod    Texture // suffix
29189                         Shaded           bool
29190                         ShowOnMinimap    bool
29191                         NametagBG        color.NRGBA
29192                 }))(obj)).CollideWithNodes
29193                 switch n := read8(r); n {
29194                 case 0:
29195                         *p = false
29196                 case 1:
29197                         *p = true
29198                 default:
29199                         chk(fmt.Errorf("invalid bool: %d", n))
29200                 }
29201
29202         }
29203         {
29204                 p := &(*(*(struct {
29205                         MaxHP            uint16 // Player only.
29206                         CollideWithNodes bool
29207                         Weight           float32 // deprecated
29208                         ColBox, SelBox   Box
29209                         Pointable        bool
29210                         Visual           string
29211                         VisualSize       [3]float32
29212                         Textures         []Texture
29213                         SpriteSheetSize  [2]int16 // in sprites.
29214                         SpritePos        [2]int16 // in sprite sheet.
29215                         Visible          bool
29216                         MakeFootstepSnds bool
29217                         RotateSpeed      float32 // in radians per second.
29218                         Mesh             string
29219                         Colors           []color.NRGBA
29220                         CollideWithAOs   bool
29221                         StepHeight       float32
29222                         FaceRotateDir    bool
29223                         FaceRotateDirOff float32 // in degrees.
29224                         BackfaceCull     bool
29225                         Nametag          string
29226                         NametagColor     color.NRGBA
29227                         FaceRotateSpeed  float32 // in degrees per second.
29228                         Infotext         string
29229                         Itemstring       string
29230                         Glow             int8
29231                         MaxBreath        uint16  // Player only.
29232                         EyeHeight        float32 // Player only.
29233                         ZoomFOV          float32 // in degrees. Player only.
29234                         UseTextureAlpha  bool
29235                         DmgTextureMod    Texture // suffix
29236                         Shaded           bool
29237                         ShowOnMinimap    bool
29238                         NametagBG        color.NRGBA
29239                 }))(obj)).Weight
29240                 *p = math.Float32frombits(read32(r))
29241         }
29242         if err := pcall(func() {
29243                 ((*(*(struct {
29244                         MaxHP            uint16 // Player only.
29245                         CollideWithNodes bool
29246                         Weight           float32 // deprecated
29247                         ColBox, SelBox   Box
29248                         Pointable        bool
29249                         Visual           string
29250                         VisualSize       [3]float32
29251                         Textures         []Texture
29252                         SpriteSheetSize  [2]int16 // in sprites.
29253                         SpritePos        [2]int16 // in sprite sheet.
29254                         Visible          bool
29255                         MakeFootstepSnds bool
29256                         RotateSpeed      float32 // in radians per second.
29257                         Mesh             string
29258                         Colors           []color.NRGBA
29259                         CollideWithAOs   bool
29260                         StepHeight       float32
29261                         FaceRotateDir    bool
29262                         FaceRotateDirOff float32 // in degrees.
29263                         BackfaceCull     bool
29264                         Nametag          string
29265                         NametagColor     color.NRGBA
29266                         FaceRotateSpeed  float32 // in degrees per second.
29267                         Infotext         string
29268                         Itemstring       string
29269                         Glow             int8
29270                         MaxBreath        uint16  // Player only.
29271                         EyeHeight        float32 // Player only.
29272                         ZoomFOV          float32 // in degrees. Player only.
29273                         UseTextureAlpha  bool
29274                         DmgTextureMod    Texture // suffix
29275                         Shaded           bool
29276                         ShowOnMinimap    bool
29277                         NametagBG        color.NRGBA
29278                 }))(obj)).ColBox).deserialize(r)
29279         }); err != nil {
29280                 if err == io.EOF {
29281                         chk(io.EOF)
29282                 }
29283                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
29284         }
29285         if err := pcall(func() {
29286                 ((*(*(struct {
29287                         MaxHP            uint16 // Player only.
29288                         CollideWithNodes bool
29289                         Weight           float32 // deprecated
29290                         ColBox, SelBox   Box
29291                         Pointable        bool
29292                         Visual           string
29293                         VisualSize       [3]float32
29294                         Textures         []Texture
29295                         SpriteSheetSize  [2]int16 // in sprites.
29296                         SpritePos        [2]int16 // in sprite sheet.
29297                         Visible          bool
29298                         MakeFootstepSnds bool
29299                         RotateSpeed      float32 // in radians per second.
29300                         Mesh             string
29301                         Colors           []color.NRGBA
29302                         CollideWithAOs   bool
29303                         StepHeight       float32
29304                         FaceRotateDir    bool
29305                         FaceRotateDirOff float32 // in degrees.
29306                         BackfaceCull     bool
29307                         Nametag          string
29308                         NametagColor     color.NRGBA
29309                         FaceRotateSpeed  float32 // in degrees per second.
29310                         Infotext         string
29311                         Itemstring       string
29312                         Glow             int8
29313                         MaxBreath        uint16  // Player only.
29314                         EyeHeight        float32 // Player only.
29315                         ZoomFOV          float32 // in degrees. Player only.
29316                         UseTextureAlpha  bool
29317                         DmgTextureMod    Texture // suffix
29318                         Shaded           bool
29319                         ShowOnMinimap    bool
29320                         NametagBG        color.NRGBA
29321                 }))(obj)).SelBox).deserialize(r)
29322         }); err != nil {
29323                 if err == io.EOF {
29324                         chk(io.EOF)
29325                 }
29326                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
29327         }
29328         {
29329                 p := &(*(*(struct {
29330                         MaxHP            uint16 // Player only.
29331                         CollideWithNodes bool
29332                         Weight           float32 // deprecated
29333                         ColBox, SelBox   Box
29334                         Pointable        bool
29335                         Visual           string
29336                         VisualSize       [3]float32
29337                         Textures         []Texture
29338                         SpriteSheetSize  [2]int16 // in sprites.
29339                         SpritePos        [2]int16 // in sprite sheet.
29340                         Visible          bool
29341                         MakeFootstepSnds bool
29342                         RotateSpeed      float32 // in radians per second.
29343                         Mesh             string
29344                         Colors           []color.NRGBA
29345                         CollideWithAOs   bool
29346                         StepHeight       float32
29347                         FaceRotateDir    bool
29348                         FaceRotateDirOff float32 // in degrees.
29349                         BackfaceCull     bool
29350                         Nametag          string
29351                         NametagColor     color.NRGBA
29352                         FaceRotateSpeed  float32 // in degrees per second.
29353                         Infotext         string
29354                         Itemstring       string
29355                         Glow             int8
29356                         MaxBreath        uint16  // Player only.
29357                         EyeHeight        float32 // Player only.
29358                         ZoomFOV          float32 // in degrees. Player only.
29359                         UseTextureAlpha  bool
29360                         DmgTextureMod    Texture // suffix
29361                         Shaded           bool
29362                         ShowOnMinimap    bool
29363                         NametagBG        color.NRGBA
29364                 }))(obj)).Pointable
29365                 switch n := read8(r); n {
29366                 case 0:
29367                         *p = false
29368                 case 1:
29369                         *p = true
29370                 default:
29371                         chk(fmt.Errorf("invalid bool: %d", n))
29372                 }
29373
29374         }
29375         var local341 []uint8
29376         var local342 uint16
29377         {
29378                 p := &local342
29379                 *p = read16(r)
29380         }
29381         (local341) = make([]uint8, local342)
29382         {
29383                 _, err := io.ReadFull(r, (local341)[:])
29384                 chk(err)
29385         }
29386         ((*(*(struct {
29387                 MaxHP            uint16 // Player only.
29388                 CollideWithNodes bool
29389                 Weight           float32 // deprecated
29390                 ColBox, SelBox   Box
29391                 Pointable        bool
29392                 Visual           string
29393                 VisualSize       [3]float32
29394                 Textures         []Texture
29395                 SpriteSheetSize  [2]int16 // in sprites.
29396                 SpritePos        [2]int16 // in sprite sheet.
29397                 Visible          bool
29398                 MakeFootstepSnds bool
29399                 RotateSpeed      float32 // in radians per second.
29400                 Mesh             string
29401                 Colors           []color.NRGBA
29402                 CollideWithAOs   bool
29403                 StepHeight       float32
29404                 FaceRotateDir    bool
29405                 FaceRotateDirOff float32 // in degrees.
29406                 BackfaceCull     bool
29407                 Nametag          string
29408                 NametagColor     color.NRGBA
29409                 FaceRotateSpeed  float32 // in degrees per second.
29410                 Infotext         string
29411                 Itemstring       string
29412                 Glow             int8
29413                 MaxBreath        uint16  // Player only.
29414                 EyeHeight        float32 // Player only.
29415                 ZoomFOV          float32 // in degrees. Player only.
29416                 UseTextureAlpha  bool
29417                 DmgTextureMod    Texture // suffix
29418                 Shaded           bool
29419                 ShowOnMinimap    bool
29420                 NametagBG        color.NRGBA
29421         }))(obj)).Visual) = string(local341)
29422         for local343 := range (*(*(struct {
29423                 MaxHP            uint16 // Player only.
29424                 CollideWithNodes bool
29425                 Weight           float32 // deprecated
29426                 ColBox, SelBox   Box
29427                 Pointable        bool
29428                 Visual           string
29429                 VisualSize       [3]float32
29430                 Textures         []Texture
29431                 SpriteSheetSize  [2]int16 // in sprites.
29432                 SpritePos        [2]int16 // in sprite sheet.
29433                 Visible          bool
29434                 MakeFootstepSnds bool
29435                 RotateSpeed      float32 // in radians per second.
29436                 Mesh             string
29437                 Colors           []color.NRGBA
29438                 CollideWithAOs   bool
29439                 StepHeight       float32
29440                 FaceRotateDir    bool
29441                 FaceRotateDirOff float32 // in degrees.
29442                 BackfaceCull     bool
29443                 Nametag          string
29444                 NametagColor     color.NRGBA
29445                 FaceRotateSpeed  float32 // in degrees per second.
29446                 Infotext         string
29447                 Itemstring       string
29448                 Glow             int8
29449                 MaxBreath        uint16  // Player only.
29450                 EyeHeight        float32 // Player only.
29451                 ZoomFOV          float32 // in degrees. Player only.
29452                 UseTextureAlpha  bool
29453                 DmgTextureMod    Texture // suffix
29454                 Shaded           bool
29455                 ShowOnMinimap    bool
29456                 NametagBG        color.NRGBA
29457         }))(obj)).VisualSize {
29458                 {
29459                         p := &((*(*(struct {
29460                                 MaxHP            uint16 // Player only.
29461                                 CollideWithNodes bool
29462                                 Weight           float32 // deprecated
29463                                 ColBox, SelBox   Box
29464                                 Pointable        bool
29465                                 Visual           string
29466                                 VisualSize       [3]float32
29467                                 Textures         []Texture
29468                                 SpriteSheetSize  [2]int16 // in sprites.
29469                                 SpritePos        [2]int16 // in sprite sheet.
29470                                 Visible          bool
29471                                 MakeFootstepSnds bool
29472                                 RotateSpeed      float32 // in radians per second.
29473                                 Mesh             string
29474                                 Colors           []color.NRGBA
29475                                 CollideWithAOs   bool
29476                                 StepHeight       float32
29477                                 FaceRotateDir    bool
29478                                 FaceRotateDirOff float32 // in degrees.
29479                                 BackfaceCull     bool
29480                                 Nametag          string
29481                                 NametagColor     color.NRGBA
29482                                 FaceRotateSpeed  float32 // in degrees per second.
29483                                 Infotext         string
29484                                 Itemstring       string
29485                                 Glow             int8
29486                                 MaxBreath        uint16  // Player only.
29487                                 EyeHeight        float32 // Player only.
29488                                 ZoomFOV          float32 // in degrees. Player only.
29489                                 UseTextureAlpha  bool
29490                                 DmgTextureMod    Texture // suffix
29491                                 Shaded           bool
29492                                 ShowOnMinimap    bool
29493                                 NametagBG        color.NRGBA
29494                         }))(obj)).VisualSize)[local343]
29495                         *p = math.Float32frombits(read32(r))
29496                 }
29497         }
29498         var local344 uint16
29499         {
29500                 p := &local344
29501                 *p = read16(r)
29502         }
29503         ((*(*(struct {
29504                 MaxHP            uint16 // Player only.
29505                 CollideWithNodes bool
29506                 Weight           float32 // deprecated
29507                 ColBox, SelBox   Box
29508                 Pointable        bool
29509                 Visual           string
29510                 VisualSize       [3]float32
29511                 Textures         []Texture
29512                 SpriteSheetSize  [2]int16 // in sprites.
29513                 SpritePos        [2]int16 // in sprite sheet.
29514                 Visible          bool
29515                 MakeFootstepSnds bool
29516                 RotateSpeed      float32 // in radians per second.
29517                 Mesh             string
29518                 Colors           []color.NRGBA
29519                 CollideWithAOs   bool
29520                 StepHeight       float32
29521                 FaceRotateDir    bool
29522                 FaceRotateDirOff float32 // in degrees.
29523                 BackfaceCull     bool
29524                 Nametag          string
29525                 NametagColor     color.NRGBA
29526                 FaceRotateSpeed  float32 // in degrees per second.
29527                 Infotext         string
29528                 Itemstring       string
29529                 Glow             int8
29530                 MaxBreath        uint16  // Player only.
29531                 EyeHeight        float32 // Player only.
29532                 ZoomFOV          float32 // in degrees. Player only.
29533                 UseTextureAlpha  bool
29534                 DmgTextureMod    Texture // suffix
29535                 Shaded           bool
29536                 ShowOnMinimap    bool
29537                 NametagBG        color.NRGBA
29538         }))(obj)).Textures) = make([]Texture, local344)
29539         for local345 := range (*(*(struct {
29540                 MaxHP            uint16 // Player only.
29541                 CollideWithNodes bool
29542                 Weight           float32 // deprecated
29543                 ColBox, SelBox   Box
29544                 Pointable        bool
29545                 Visual           string
29546                 VisualSize       [3]float32
29547                 Textures         []Texture
29548                 SpriteSheetSize  [2]int16 // in sprites.
29549                 SpritePos        [2]int16 // in sprite sheet.
29550                 Visible          bool
29551                 MakeFootstepSnds bool
29552                 RotateSpeed      float32 // in radians per second.
29553                 Mesh             string
29554                 Colors           []color.NRGBA
29555                 CollideWithAOs   bool
29556                 StepHeight       float32
29557                 FaceRotateDir    bool
29558                 FaceRotateDirOff float32 // in degrees.
29559                 BackfaceCull     bool
29560                 Nametag          string
29561                 NametagColor     color.NRGBA
29562                 FaceRotateSpeed  float32 // in degrees per second.
29563                 Infotext         string
29564                 Itemstring       string
29565                 Glow             int8
29566                 MaxBreath        uint16  // Player only.
29567                 EyeHeight        float32 // Player only.
29568                 ZoomFOV          float32 // in degrees. Player only.
29569                 UseTextureAlpha  bool
29570                 DmgTextureMod    Texture // suffix
29571                 Shaded           bool
29572                 ShowOnMinimap    bool
29573                 NametagBG        color.NRGBA
29574         }))(obj)).Textures {
29575                 if err := pcall(func() {
29576                         (((*(*(struct {
29577                                 MaxHP            uint16 // Player only.
29578                                 CollideWithNodes bool
29579                                 Weight           float32 // deprecated
29580                                 ColBox, SelBox   Box
29581                                 Pointable        bool
29582                                 Visual           string
29583                                 VisualSize       [3]float32
29584                                 Textures         []Texture
29585                                 SpriteSheetSize  [2]int16 // in sprites.
29586                                 SpritePos        [2]int16 // in sprite sheet.
29587                                 Visible          bool
29588                                 MakeFootstepSnds bool
29589                                 RotateSpeed      float32 // in radians per second.
29590                                 Mesh             string
29591                                 Colors           []color.NRGBA
29592                                 CollideWithAOs   bool
29593                                 StepHeight       float32
29594                                 FaceRotateDir    bool
29595                                 FaceRotateDirOff float32 // in degrees.
29596                                 BackfaceCull     bool
29597                                 Nametag          string
29598                                 NametagColor     color.NRGBA
29599                                 FaceRotateSpeed  float32 // in degrees per second.
29600                                 Infotext         string
29601                                 Itemstring       string
29602                                 Glow             int8
29603                                 MaxBreath        uint16  // Player only.
29604                                 EyeHeight        float32 // Player only.
29605                                 ZoomFOV          float32 // in degrees. Player only.
29606                                 UseTextureAlpha  bool
29607                                 DmgTextureMod    Texture // suffix
29608                                 Shaded           bool
29609                                 ShowOnMinimap    bool
29610                                 NametagBG        color.NRGBA
29611                         }))(obj)).Textures)[local345]).deserialize(r)
29612                 }); err != nil {
29613                         if err == io.EOF {
29614                                 chk(io.EOF)
29615                         }
29616                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
29617                 }
29618         }
29619         for local346 := range (*(*(struct {
29620                 MaxHP            uint16 // Player only.
29621                 CollideWithNodes bool
29622                 Weight           float32 // deprecated
29623                 ColBox, SelBox   Box
29624                 Pointable        bool
29625                 Visual           string
29626                 VisualSize       [3]float32
29627                 Textures         []Texture
29628                 SpriteSheetSize  [2]int16 // in sprites.
29629                 SpritePos        [2]int16 // in sprite sheet.
29630                 Visible          bool
29631                 MakeFootstepSnds bool
29632                 RotateSpeed      float32 // in radians per second.
29633                 Mesh             string
29634                 Colors           []color.NRGBA
29635                 CollideWithAOs   bool
29636                 StepHeight       float32
29637                 FaceRotateDir    bool
29638                 FaceRotateDirOff float32 // in degrees.
29639                 BackfaceCull     bool
29640                 Nametag          string
29641                 NametagColor     color.NRGBA
29642                 FaceRotateSpeed  float32 // in degrees per second.
29643                 Infotext         string
29644                 Itemstring       string
29645                 Glow             int8
29646                 MaxBreath        uint16  // Player only.
29647                 EyeHeight        float32 // Player only.
29648                 ZoomFOV          float32 // in degrees. Player only.
29649                 UseTextureAlpha  bool
29650                 DmgTextureMod    Texture // suffix
29651                 Shaded           bool
29652                 ShowOnMinimap    bool
29653                 NametagBG        color.NRGBA
29654         }))(obj)).SpriteSheetSize {
29655                 {
29656                         p := &((*(*(struct {
29657                                 MaxHP            uint16 // Player only.
29658                                 CollideWithNodes bool
29659                                 Weight           float32 // deprecated
29660                                 ColBox, SelBox   Box
29661                                 Pointable        bool
29662                                 Visual           string
29663                                 VisualSize       [3]float32
29664                                 Textures         []Texture
29665                                 SpriteSheetSize  [2]int16 // in sprites.
29666                                 SpritePos        [2]int16 // in sprite sheet.
29667                                 Visible          bool
29668                                 MakeFootstepSnds bool
29669                                 RotateSpeed      float32 // in radians per second.
29670                                 Mesh             string
29671                                 Colors           []color.NRGBA
29672                                 CollideWithAOs   bool
29673                                 StepHeight       float32
29674                                 FaceRotateDir    bool
29675                                 FaceRotateDirOff float32 // in degrees.
29676                                 BackfaceCull     bool
29677                                 Nametag          string
29678                                 NametagColor     color.NRGBA
29679                                 FaceRotateSpeed  float32 // in degrees per second.
29680                                 Infotext         string
29681                                 Itemstring       string
29682                                 Glow             int8
29683                                 MaxBreath        uint16  // Player only.
29684                                 EyeHeight        float32 // Player only.
29685                                 ZoomFOV          float32 // in degrees. Player only.
29686                                 UseTextureAlpha  bool
29687                                 DmgTextureMod    Texture // suffix
29688                                 Shaded           bool
29689                                 ShowOnMinimap    bool
29690                                 NametagBG        color.NRGBA
29691                         }))(obj)).SpriteSheetSize)[local346]
29692                         *p = int16(read16(r))
29693                 }
29694         }
29695         for local347 := range (*(*(struct {
29696                 MaxHP            uint16 // Player only.
29697                 CollideWithNodes bool
29698                 Weight           float32 // deprecated
29699                 ColBox, SelBox   Box
29700                 Pointable        bool
29701                 Visual           string
29702                 VisualSize       [3]float32
29703                 Textures         []Texture
29704                 SpriteSheetSize  [2]int16 // in sprites.
29705                 SpritePos        [2]int16 // in sprite sheet.
29706                 Visible          bool
29707                 MakeFootstepSnds bool
29708                 RotateSpeed      float32 // in radians per second.
29709                 Mesh             string
29710                 Colors           []color.NRGBA
29711                 CollideWithAOs   bool
29712                 StepHeight       float32
29713                 FaceRotateDir    bool
29714                 FaceRotateDirOff float32 // in degrees.
29715                 BackfaceCull     bool
29716                 Nametag          string
29717                 NametagColor     color.NRGBA
29718                 FaceRotateSpeed  float32 // in degrees per second.
29719                 Infotext         string
29720                 Itemstring       string
29721                 Glow             int8
29722                 MaxBreath        uint16  // Player only.
29723                 EyeHeight        float32 // Player only.
29724                 ZoomFOV          float32 // in degrees. Player only.
29725                 UseTextureAlpha  bool
29726                 DmgTextureMod    Texture // suffix
29727                 Shaded           bool
29728                 ShowOnMinimap    bool
29729                 NametagBG        color.NRGBA
29730         }))(obj)).SpritePos {
29731                 {
29732                         p := &((*(*(struct {
29733                                 MaxHP            uint16 // Player only.
29734                                 CollideWithNodes bool
29735                                 Weight           float32 // deprecated
29736                                 ColBox, SelBox   Box
29737                                 Pointable        bool
29738                                 Visual           string
29739                                 VisualSize       [3]float32
29740                                 Textures         []Texture
29741                                 SpriteSheetSize  [2]int16 // in sprites.
29742                                 SpritePos        [2]int16 // in sprite sheet.
29743                                 Visible          bool
29744                                 MakeFootstepSnds bool
29745                                 RotateSpeed      float32 // in radians per second.
29746                                 Mesh             string
29747                                 Colors           []color.NRGBA
29748                                 CollideWithAOs   bool
29749                                 StepHeight       float32
29750                                 FaceRotateDir    bool
29751                                 FaceRotateDirOff float32 // in degrees.
29752                                 BackfaceCull     bool
29753                                 Nametag          string
29754                                 NametagColor     color.NRGBA
29755                                 FaceRotateSpeed  float32 // in degrees per second.
29756                                 Infotext         string
29757                                 Itemstring       string
29758                                 Glow             int8
29759                                 MaxBreath        uint16  // Player only.
29760                                 EyeHeight        float32 // Player only.
29761                                 ZoomFOV          float32 // in degrees. Player only.
29762                                 UseTextureAlpha  bool
29763                                 DmgTextureMod    Texture // suffix
29764                                 Shaded           bool
29765                                 ShowOnMinimap    bool
29766                                 NametagBG        color.NRGBA
29767                         }))(obj)).SpritePos)[local347]
29768                         *p = int16(read16(r))
29769                 }
29770         }
29771         {
29772                 p := &(*(*(struct {
29773                         MaxHP            uint16 // Player only.
29774                         CollideWithNodes bool
29775                         Weight           float32 // deprecated
29776                         ColBox, SelBox   Box
29777                         Pointable        bool
29778                         Visual           string
29779                         VisualSize       [3]float32
29780                         Textures         []Texture
29781                         SpriteSheetSize  [2]int16 // in sprites.
29782                         SpritePos        [2]int16 // in sprite sheet.
29783                         Visible          bool
29784                         MakeFootstepSnds bool
29785                         RotateSpeed      float32 // in radians per second.
29786                         Mesh             string
29787                         Colors           []color.NRGBA
29788                         CollideWithAOs   bool
29789                         StepHeight       float32
29790                         FaceRotateDir    bool
29791                         FaceRotateDirOff float32 // in degrees.
29792                         BackfaceCull     bool
29793                         Nametag          string
29794                         NametagColor     color.NRGBA
29795                         FaceRotateSpeed  float32 // in degrees per second.
29796                         Infotext         string
29797                         Itemstring       string
29798                         Glow             int8
29799                         MaxBreath        uint16  // Player only.
29800                         EyeHeight        float32 // Player only.
29801                         ZoomFOV          float32 // in degrees. Player only.
29802                         UseTextureAlpha  bool
29803                         DmgTextureMod    Texture // suffix
29804                         Shaded           bool
29805                         ShowOnMinimap    bool
29806                         NametagBG        color.NRGBA
29807                 }))(obj)).Visible
29808                 switch n := read8(r); n {
29809                 case 0:
29810                         *p = false
29811                 case 1:
29812                         *p = true
29813                 default:
29814                         chk(fmt.Errorf("invalid bool: %d", n))
29815                 }
29816
29817         }
29818         {
29819                 p := &(*(*(struct {
29820                         MaxHP            uint16 // Player only.
29821                         CollideWithNodes bool
29822                         Weight           float32 // deprecated
29823                         ColBox, SelBox   Box
29824                         Pointable        bool
29825                         Visual           string
29826                         VisualSize       [3]float32
29827                         Textures         []Texture
29828                         SpriteSheetSize  [2]int16 // in sprites.
29829                         SpritePos        [2]int16 // in sprite sheet.
29830                         Visible          bool
29831                         MakeFootstepSnds bool
29832                         RotateSpeed      float32 // in radians per second.
29833                         Mesh             string
29834                         Colors           []color.NRGBA
29835                         CollideWithAOs   bool
29836                         StepHeight       float32
29837                         FaceRotateDir    bool
29838                         FaceRotateDirOff float32 // in degrees.
29839                         BackfaceCull     bool
29840                         Nametag          string
29841                         NametagColor     color.NRGBA
29842                         FaceRotateSpeed  float32 // in degrees per second.
29843                         Infotext         string
29844                         Itemstring       string
29845                         Glow             int8
29846                         MaxBreath        uint16  // Player only.
29847                         EyeHeight        float32 // Player only.
29848                         ZoomFOV          float32 // in degrees. Player only.
29849                         UseTextureAlpha  bool
29850                         DmgTextureMod    Texture // suffix
29851                         Shaded           bool
29852                         ShowOnMinimap    bool
29853                         NametagBG        color.NRGBA
29854                 }))(obj)).MakeFootstepSnds
29855                 switch n := read8(r); n {
29856                 case 0:
29857                         *p = false
29858                 case 1:
29859                         *p = true
29860                 default:
29861                         chk(fmt.Errorf("invalid bool: %d", n))
29862                 }
29863
29864         }
29865         {
29866                 p := &(*(*(struct {
29867                         MaxHP            uint16 // Player only.
29868                         CollideWithNodes bool
29869                         Weight           float32 // deprecated
29870                         ColBox, SelBox   Box
29871                         Pointable        bool
29872                         Visual           string
29873                         VisualSize       [3]float32
29874                         Textures         []Texture
29875                         SpriteSheetSize  [2]int16 // in sprites.
29876                         SpritePos        [2]int16 // in sprite sheet.
29877                         Visible          bool
29878                         MakeFootstepSnds bool
29879                         RotateSpeed      float32 // in radians per second.
29880                         Mesh             string
29881                         Colors           []color.NRGBA
29882                         CollideWithAOs   bool
29883                         StepHeight       float32
29884                         FaceRotateDir    bool
29885                         FaceRotateDirOff float32 // in degrees.
29886                         BackfaceCull     bool
29887                         Nametag          string
29888                         NametagColor     color.NRGBA
29889                         FaceRotateSpeed  float32 // in degrees per second.
29890                         Infotext         string
29891                         Itemstring       string
29892                         Glow             int8
29893                         MaxBreath        uint16  // Player only.
29894                         EyeHeight        float32 // Player only.
29895                         ZoomFOV          float32 // in degrees. Player only.
29896                         UseTextureAlpha  bool
29897                         DmgTextureMod    Texture // suffix
29898                         Shaded           bool
29899                         ShowOnMinimap    bool
29900                         NametagBG        color.NRGBA
29901                 }))(obj)).RotateSpeed
29902                 *p = math.Float32frombits(read32(r))
29903         }
29904         var local348 []uint8
29905         var local349 uint16
29906         {
29907                 p := &local349
29908                 *p = read16(r)
29909         }
29910         (local348) = make([]uint8, local349)
29911         {
29912                 _, err := io.ReadFull(r, (local348)[:])
29913                 chk(err)
29914         }
29915         ((*(*(struct {
29916                 MaxHP            uint16 // Player only.
29917                 CollideWithNodes bool
29918                 Weight           float32 // deprecated
29919                 ColBox, SelBox   Box
29920                 Pointable        bool
29921                 Visual           string
29922                 VisualSize       [3]float32
29923                 Textures         []Texture
29924                 SpriteSheetSize  [2]int16 // in sprites.
29925                 SpritePos        [2]int16 // in sprite sheet.
29926                 Visible          bool
29927                 MakeFootstepSnds bool
29928                 RotateSpeed      float32 // in radians per second.
29929                 Mesh             string
29930                 Colors           []color.NRGBA
29931                 CollideWithAOs   bool
29932                 StepHeight       float32
29933                 FaceRotateDir    bool
29934                 FaceRotateDirOff float32 // in degrees.
29935                 BackfaceCull     bool
29936                 Nametag          string
29937                 NametagColor     color.NRGBA
29938                 FaceRotateSpeed  float32 // in degrees per second.
29939                 Infotext         string
29940                 Itemstring       string
29941                 Glow             int8
29942                 MaxBreath        uint16  // Player only.
29943                 EyeHeight        float32 // Player only.
29944                 ZoomFOV          float32 // in degrees. Player only.
29945                 UseTextureAlpha  bool
29946                 DmgTextureMod    Texture // suffix
29947                 Shaded           bool
29948                 ShowOnMinimap    bool
29949                 NametagBG        color.NRGBA
29950         }))(obj)).Mesh) = string(local348)
29951         var local350 uint16
29952         {
29953                 p := &local350
29954                 *p = read16(r)
29955         }
29956         ((*(*(struct {
29957                 MaxHP            uint16 // Player only.
29958                 CollideWithNodes bool
29959                 Weight           float32 // deprecated
29960                 ColBox, SelBox   Box
29961                 Pointable        bool
29962                 Visual           string
29963                 VisualSize       [3]float32
29964                 Textures         []Texture
29965                 SpriteSheetSize  [2]int16 // in sprites.
29966                 SpritePos        [2]int16 // in sprite sheet.
29967                 Visible          bool
29968                 MakeFootstepSnds bool
29969                 RotateSpeed      float32 // in radians per second.
29970                 Mesh             string
29971                 Colors           []color.NRGBA
29972                 CollideWithAOs   bool
29973                 StepHeight       float32
29974                 FaceRotateDir    bool
29975                 FaceRotateDirOff float32 // in degrees.
29976                 BackfaceCull     bool
29977                 Nametag          string
29978                 NametagColor     color.NRGBA
29979                 FaceRotateSpeed  float32 // in degrees per second.
29980                 Infotext         string
29981                 Itemstring       string
29982                 Glow             int8
29983                 MaxBreath        uint16  // Player only.
29984                 EyeHeight        float32 // Player only.
29985                 ZoomFOV          float32 // in degrees. Player only.
29986                 UseTextureAlpha  bool
29987                 DmgTextureMod    Texture // suffix
29988                 Shaded           bool
29989                 ShowOnMinimap    bool
29990                 NametagBG        color.NRGBA
29991         }))(obj)).Colors) = make([]color.NRGBA, local350)
29992         for local351 := range (*(*(struct {
29993                 MaxHP            uint16 // Player only.
29994                 CollideWithNodes bool
29995                 Weight           float32 // deprecated
29996                 ColBox, SelBox   Box
29997                 Pointable        bool
29998                 Visual           string
29999                 VisualSize       [3]float32
30000                 Textures         []Texture
30001                 SpriteSheetSize  [2]int16 // in sprites.
30002                 SpritePos        [2]int16 // in sprite sheet.
30003                 Visible          bool
30004                 MakeFootstepSnds bool
30005                 RotateSpeed      float32 // in radians per second.
30006                 Mesh             string
30007                 Colors           []color.NRGBA
30008                 CollideWithAOs   bool
30009                 StepHeight       float32
30010                 FaceRotateDir    bool
30011                 FaceRotateDirOff float32 // in degrees.
30012                 BackfaceCull     bool
30013                 Nametag          string
30014                 NametagColor     color.NRGBA
30015                 FaceRotateSpeed  float32 // in degrees per second.
30016                 Infotext         string
30017                 Itemstring       string
30018                 Glow             int8
30019                 MaxBreath        uint16  // Player only.
30020                 EyeHeight        float32 // Player only.
30021                 ZoomFOV          float32 // in degrees. Player only.
30022                 UseTextureAlpha  bool
30023                 DmgTextureMod    Texture // suffix
30024                 Shaded           bool
30025                 ShowOnMinimap    bool
30026                 NametagBG        color.NRGBA
30027         }))(obj)).Colors {
30028                 {
30029                         p := &((*(*(struct {
30030                                 MaxHP            uint16 // Player only.
30031                                 CollideWithNodes bool
30032                                 Weight           float32 // deprecated
30033                                 ColBox, SelBox   Box
30034                                 Pointable        bool
30035                                 Visual           string
30036                                 VisualSize       [3]float32
30037                                 Textures         []Texture
30038                                 SpriteSheetSize  [2]int16 // in sprites.
30039                                 SpritePos        [2]int16 // in sprite sheet.
30040                                 Visible          bool
30041                                 MakeFootstepSnds bool
30042                                 RotateSpeed      float32 // in radians per second.
30043                                 Mesh             string
30044                                 Colors           []color.NRGBA
30045                                 CollideWithAOs   bool
30046                                 StepHeight       float32
30047                                 FaceRotateDir    bool
30048                                 FaceRotateDirOff float32 // in degrees.
30049                                 BackfaceCull     bool
30050                                 Nametag          string
30051                                 NametagColor     color.NRGBA
30052                                 FaceRotateSpeed  float32 // in degrees per second.
30053                                 Infotext         string
30054                                 Itemstring       string
30055                                 Glow             int8
30056                                 MaxBreath        uint16  // Player only.
30057                                 EyeHeight        float32 // Player only.
30058                                 ZoomFOV          float32 // in degrees. Player only.
30059                                 UseTextureAlpha  bool
30060                                 DmgTextureMod    Texture // suffix
30061                                 Shaded           bool
30062                                 ShowOnMinimap    bool
30063                                 NametagBG        color.NRGBA
30064                         }))(obj)).Colors)[local351]
30065                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30066
30067                 }
30068         }
30069         {
30070                 p := &(*(*(struct {
30071                         MaxHP            uint16 // Player only.
30072                         CollideWithNodes bool
30073                         Weight           float32 // deprecated
30074                         ColBox, SelBox   Box
30075                         Pointable        bool
30076                         Visual           string
30077                         VisualSize       [3]float32
30078                         Textures         []Texture
30079                         SpriteSheetSize  [2]int16 // in sprites.
30080                         SpritePos        [2]int16 // in sprite sheet.
30081                         Visible          bool
30082                         MakeFootstepSnds bool
30083                         RotateSpeed      float32 // in radians per second.
30084                         Mesh             string
30085                         Colors           []color.NRGBA
30086                         CollideWithAOs   bool
30087                         StepHeight       float32
30088                         FaceRotateDir    bool
30089                         FaceRotateDirOff float32 // in degrees.
30090                         BackfaceCull     bool
30091                         Nametag          string
30092                         NametagColor     color.NRGBA
30093                         FaceRotateSpeed  float32 // in degrees per second.
30094                         Infotext         string
30095                         Itemstring       string
30096                         Glow             int8
30097                         MaxBreath        uint16  // Player only.
30098                         EyeHeight        float32 // Player only.
30099                         ZoomFOV          float32 // in degrees. Player only.
30100                         UseTextureAlpha  bool
30101                         DmgTextureMod    Texture // suffix
30102                         Shaded           bool
30103                         ShowOnMinimap    bool
30104                         NametagBG        color.NRGBA
30105                 }))(obj)).CollideWithAOs
30106                 switch n := read8(r); n {
30107                 case 0:
30108                         *p = false
30109                 case 1:
30110                         *p = true
30111                 default:
30112                         chk(fmt.Errorf("invalid bool: %d", n))
30113                 }
30114
30115         }
30116         {
30117                 p := &(*(*(struct {
30118                         MaxHP            uint16 // Player only.
30119                         CollideWithNodes bool
30120                         Weight           float32 // deprecated
30121                         ColBox, SelBox   Box
30122                         Pointable        bool
30123                         Visual           string
30124                         VisualSize       [3]float32
30125                         Textures         []Texture
30126                         SpriteSheetSize  [2]int16 // in sprites.
30127                         SpritePos        [2]int16 // in sprite sheet.
30128                         Visible          bool
30129                         MakeFootstepSnds bool
30130                         RotateSpeed      float32 // in radians per second.
30131                         Mesh             string
30132                         Colors           []color.NRGBA
30133                         CollideWithAOs   bool
30134                         StepHeight       float32
30135                         FaceRotateDir    bool
30136                         FaceRotateDirOff float32 // in degrees.
30137                         BackfaceCull     bool
30138                         Nametag          string
30139                         NametagColor     color.NRGBA
30140                         FaceRotateSpeed  float32 // in degrees per second.
30141                         Infotext         string
30142                         Itemstring       string
30143                         Glow             int8
30144                         MaxBreath        uint16  // Player only.
30145                         EyeHeight        float32 // Player only.
30146                         ZoomFOV          float32 // in degrees. Player only.
30147                         UseTextureAlpha  bool
30148                         DmgTextureMod    Texture // suffix
30149                         Shaded           bool
30150                         ShowOnMinimap    bool
30151                         NametagBG        color.NRGBA
30152                 }))(obj)).StepHeight
30153                 *p = math.Float32frombits(read32(r))
30154         }
30155         {
30156                 p := &(*(*(struct {
30157                         MaxHP            uint16 // Player only.
30158                         CollideWithNodes bool
30159                         Weight           float32 // deprecated
30160                         ColBox, SelBox   Box
30161                         Pointable        bool
30162                         Visual           string
30163                         VisualSize       [3]float32
30164                         Textures         []Texture
30165                         SpriteSheetSize  [2]int16 // in sprites.
30166                         SpritePos        [2]int16 // in sprite sheet.
30167                         Visible          bool
30168                         MakeFootstepSnds bool
30169                         RotateSpeed      float32 // in radians per second.
30170                         Mesh             string
30171                         Colors           []color.NRGBA
30172                         CollideWithAOs   bool
30173                         StepHeight       float32
30174                         FaceRotateDir    bool
30175                         FaceRotateDirOff float32 // in degrees.
30176                         BackfaceCull     bool
30177                         Nametag          string
30178                         NametagColor     color.NRGBA
30179                         FaceRotateSpeed  float32 // in degrees per second.
30180                         Infotext         string
30181                         Itemstring       string
30182                         Glow             int8
30183                         MaxBreath        uint16  // Player only.
30184                         EyeHeight        float32 // Player only.
30185                         ZoomFOV          float32 // in degrees. Player only.
30186                         UseTextureAlpha  bool
30187                         DmgTextureMod    Texture // suffix
30188                         Shaded           bool
30189                         ShowOnMinimap    bool
30190                         NametagBG        color.NRGBA
30191                 }))(obj)).FaceRotateDir
30192                 switch n := read8(r); n {
30193                 case 0:
30194                         *p = false
30195                 case 1:
30196                         *p = true
30197                 default:
30198                         chk(fmt.Errorf("invalid bool: %d", n))
30199                 }
30200
30201         }
30202         {
30203                 p := &(*(*(struct {
30204                         MaxHP            uint16 // Player only.
30205                         CollideWithNodes bool
30206                         Weight           float32 // deprecated
30207                         ColBox, SelBox   Box
30208                         Pointable        bool
30209                         Visual           string
30210                         VisualSize       [3]float32
30211                         Textures         []Texture
30212                         SpriteSheetSize  [2]int16 // in sprites.
30213                         SpritePos        [2]int16 // in sprite sheet.
30214                         Visible          bool
30215                         MakeFootstepSnds bool
30216                         RotateSpeed      float32 // in radians per second.
30217                         Mesh             string
30218                         Colors           []color.NRGBA
30219                         CollideWithAOs   bool
30220                         StepHeight       float32
30221                         FaceRotateDir    bool
30222                         FaceRotateDirOff float32 // in degrees.
30223                         BackfaceCull     bool
30224                         Nametag          string
30225                         NametagColor     color.NRGBA
30226                         FaceRotateSpeed  float32 // in degrees per second.
30227                         Infotext         string
30228                         Itemstring       string
30229                         Glow             int8
30230                         MaxBreath        uint16  // Player only.
30231                         EyeHeight        float32 // Player only.
30232                         ZoomFOV          float32 // in degrees. Player only.
30233                         UseTextureAlpha  bool
30234                         DmgTextureMod    Texture // suffix
30235                         Shaded           bool
30236                         ShowOnMinimap    bool
30237                         NametagBG        color.NRGBA
30238                 }))(obj)).FaceRotateDirOff
30239                 *p = math.Float32frombits(read32(r))
30240         }
30241         {
30242                 p := &(*(*(struct {
30243                         MaxHP            uint16 // Player only.
30244                         CollideWithNodes bool
30245                         Weight           float32 // deprecated
30246                         ColBox, SelBox   Box
30247                         Pointable        bool
30248                         Visual           string
30249                         VisualSize       [3]float32
30250                         Textures         []Texture
30251                         SpriteSheetSize  [2]int16 // in sprites.
30252                         SpritePos        [2]int16 // in sprite sheet.
30253                         Visible          bool
30254                         MakeFootstepSnds bool
30255                         RotateSpeed      float32 // in radians per second.
30256                         Mesh             string
30257                         Colors           []color.NRGBA
30258                         CollideWithAOs   bool
30259                         StepHeight       float32
30260                         FaceRotateDir    bool
30261                         FaceRotateDirOff float32 // in degrees.
30262                         BackfaceCull     bool
30263                         Nametag          string
30264                         NametagColor     color.NRGBA
30265                         FaceRotateSpeed  float32 // in degrees per second.
30266                         Infotext         string
30267                         Itemstring       string
30268                         Glow             int8
30269                         MaxBreath        uint16  // Player only.
30270                         EyeHeight        float32 // Player only.
30271                         ZoomFOV          float32 // in degrees. Player only.
30272                         UseTextureAlpha  bool
30273                         DmgTextureMod    Texture // suffix
30274                         Shaded           bool
30275                         ShowOnMinimap    bool
30276                         NametagBG        color.NRGBA
30277                 }))(obj)).BackfaceCull
30278                 switch n := read8(r); n {
30279                 case 0:
30280                         *p = false
30281                 case 1:
30282                         *p = true
30283                 default:
30284                         chk(fmt.Errorf("invalid bool: %d", n))
30285                 }
30286
30287         }
30288         var local352 []uint8
30289         var local353 uint16
30290         {
30291                 p := &local353
30292                 *p = read16(r)
30293         }
30294         (local352) = make([]uint8, local353)
30295         {
30296                 _, err := io.ReadFull(r, (local352)[:])
30297                 chk(err)
30298         }
30299         ((*(*(struct {
30300                 MaxHP            uint16 // Player only.
30301                 CollideWithNodes bool
30302                 Weight           float32 // deprecated
30303                 ColBox, SelBox   Box
30304                 Pointable        bool
30305                 Visual           string
30306                 VisualSize       [3]float32
30307                 Textures         []Texture
30308                 SpriteSheetSize  [2]int16 // in sprites.
30309                 SpritePos        [2]int16 // in sprite sheet.
30310                 Visible          bool
30311                 MakeFootstepSnds bool
30312                 RotateSpeed      float32 // in radians per second.
30313                 Mesh             string
30314                 Colors           []color.NRGBA
30315                 CollideWithAOs   bool
30316                 StepHeight       float32
30317                 FaceRotateDir    bool
30318                 FaceRotateDirOff float32 // in degrees.
30319                 BackfaceCull     bool
30320                 Nametag          string
30321                 NametagColor     color.NRGBA
30322                 FaceRotateSpeed  float32 // in degrees per second.
30323                 Infotext         string
30324                 Itemstring       string
30325                 Glow             int8
30326                 MaxBreath        uint16  // Player only.
30327                 EyeHeight        float32 // Player only.
30328                 ZoomFOV          float32 // in degrees. Player only.
30329                 UseTextureAlpha  bool
30330                 DmgTextureMod    Texture // suffix
30331                 Shaded           bool
30332                 ShowOnMinimap    bool
30333                 NametagBG        color.NRGBA
30334         }))(obj)).Nametag) = string(local352)
30335         {
30336                 p := &(*(*(struct {
30337                         MaxHP            uint16 // Player only.
30338                         CollideWithNodes bool
30339                         Weight           float32 // deprecated
30340                         ColBox, SelBox   Box
30341                         Pointable        bool
30342                         Visual           string
30343                         VisualSize       [3]float32
30344                         Textures         []Texture
30345                         SpriteSheetSize  [2]int16 // in sprites.
30346                         SpritePos        [2]int16 // in sprite sheet.
30347                         Visible          bool
30348                         MakeFootstepSnds bool
30349                         RotateSpeed      float32 // in radians per second.
30350                         Mesh             string
30351                         Colors           []color.NRGBA
30352                         CollideWithAOs   bool
30353                         StepHeight       float32
30354                         FaceRotateDir    bool
30355                         FaceRotateDirOff float32 // in degrees.
30356                         BackfaceCull     bool
30357                         Nametag          string
30358                         NametagColor     color.NRGBA
30359                         FaceRotateSpeed  float32 // in degrees per second.
30360                         Infotext         string
30361                         Itemstring       string
30362                         Glow             int8
30363                         MaxBreath        uint16  // Player only.
30364                         EyeHeight        float32 // Player only.
30365                         ZoomFOV          float32 // in degrees. Player only.
30366                         UseTextureAlpha  bool
30367                         DmgTextureMod    Texture // suffix
30368                         Shaded           bool
30369                         ShowOnMinimap    bool
30370                         NametagBG        color.NRGBA
30371                 }))(obj)).NametagColor
30372                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30373
30374         }
30375         {
30376                 p := &(*(*(struct {
30377                         MaxHP            uint16 // Player only.
30378                         CollideWithNodes bool
30379                         Weight           float32 // deprecated
30380                         ColBox, SelBox   Box
30381                         Pointable        bool
30382                         Visual           string
30383                         VisualSize       [3]float32
30384                         Textures         []Texture
30385                         SpriteSheetSize  [2]int16 // in sprites.
30386                         SpritePos        [2]int16 // in sprite sheet.
30387                         Visible          bool
30388                         MakeFootstepSnds bool
30389                         RotateSpeed      float32 // in radians per second.
30390                         Mesh             string
30391                         Colors           []color.NRGBA
30392                         CollideWithAOs   bool
30393                         StepHeight       float32
30394                         FaceRotateDir    bool
30395                         FaceRotateDirOff float32 // in degrees.
30396                         BackfaceCull     bool
30397                         Nametag          string
30398                         NametagColor     color.NRGBA
30399                         FaceRotateSpeed  float32 // in degrees per second.
30400                         Infotext         string
30401                         Itemstring       string
30402                         Glow             int8
30403                         MaxBreath        uint16  // Player only.
30404                         EyeHeight        float32 // Player only.
30405                         ZoomFOV          float32 // in degrees. Player only.
30406                         UseTextureAlpha  bool
30407                         DmgTextureMod    Texture // suffix
30408                         Shaded           bool
30409                         ShowOnMinimap    bool
30410                         NametagBG        color.NRGBA
30411                 }))(obj)).FaceRotateSpeed
30412                 *p = math.Float32frombits(read32(r))
30413         }
30414         var local354 []uint8
30415         var local355 uint16
30416         {
30417                 p := &local355
30418                 *p = read16(r)
30419         }
30420         (local354) = make([]uint8, local355)
30421         {
30422                 _, err := io.ReadFull(r, (local354)[:])
30423                 chk(err)
30424         }
30425         ((*(*(struct {
30426                 MaxHP            uint16 // Player only.
30427                 CollideWithNodes bool
30428                 Weight           float32 // deprecated
30429                 ColBox, SelBox   Box
30430                 Pointable        bool
30431                 Visual           string
30432                 VisualSize       [3]float32
30433                 Textures         []Texture
30434                 SpriteSheetSize  [2]int16 // in sprites.
30435                 SpritePos        [2]int16 // in sprite sheet.
30436                 Visible          bool
30437                 MakeFootstepSnds bool
30438                 RotateSpeed      float32 // in radians per second.
30439                 Mesh             string
30440                 Colors           []color.NRGBA
30441                 CollideWithAOs   bool
30442                 StepHeight       float32
30443                 FaceRotateDir    bool
30444                 FaceRotateDirOff float32 // in degrees.
30445                 BackfaceCull     bool
30446                 Nametag          string
30447                 NametagColor     color.NRGBA
30448                 FaceRotateSpeed  float32 // in degrees per second.
30449                 Infotext         string
30450                 Itemstring       string
30451                 Glow             int8
30452                 MaxBreath        uint16  // Player only.
30453                 EyeHeight        float32 // Player only.
30454                 ZoomFOV          float32 // in degrees. Player only.
30455                 UseTextureAlpha  bool
30456                 DmgTextureMod    Texture // suffix
30457                 Shaded           bool
30458                 ShowOnMinimap    bool
30459                 NametagBG        color.NRGBA
30460         }))(obj)).Infotext) = string(local354)
30461         var local356 []uint8
30462         var local357 uint16
30463         {
30464                 p := &local357
30465                 *p = read16(r)
30466         }
30467         (local356) = make([]uint8, local357)
30468         {
30469                 _, err := io.ReadFull(r, (local356)[:])
30470                 chk(err)
30471         }
30472         ((*(*(struct {
30473                 MaxHP            uint16 // Player only.
30474                 CollideWithNodes bool
30475                 Weight           float32 // deprecated
30476                 ColBox, SelBox   Box
30477                 Pointable        bool
30478                 Visual           string
30479                 VisualSize       [3]float32
30480                 Textures         []Texture
30481                 SpriteSheetSize  [2]int16 // in sprites.
30482                 SpritePos        [2]int16 // in sprite sheet.
30483                 Visible          bool
30484                 MakeFootstepSnds bool
30485                 RotateSpeed      float32 // in radians per second.
30486                 Mesh             string
30487                 Colors           []color.NRGBA
30488                 CollideWithAOs   bool
30489                 StepHeight       float32
30490                 FaceRotateDir    bool
30491                 FaceRotateDirOff float32 // in degrees.
30492                 BackfaceCull     bool
30493                 Nametag          string
30494                 NametagColor     color.NRGBA
30495                 FaceRotateSpeed  float32 // in degrees per second.
30496                 Infotext         string
30497                 Itemstring       string
30498                 Glow             int8
30499                 MaxBreath        uint16  // Player only.
30500                 EyeHeight        float32 // Player only.
30501                 ZoomFOV          float32 // in degrees. Player only.
30502                 UseTextureAlpha  bool
30503                 DmgTextureMod    Texture // suffix
30504                 Shaded           bool
30505                 ShowOnMinimap    bool
30506                 NametagBG        color.NRGBA
30507         }))(obj)).Itemstring) = string(local356)
30508         {
30509                 p := &(*(*(struct {
30510                         MaxHP            uint16 // Player only.
30511                         CollideWithNodes bool
30512                         Weight           float32 // deprecated
30513                         ColBox, SelBox   Box
30514                         Pointable        bool
30515                         Visual           string
30516                         VisualSize       [3]float32
30517                         Textures         []Texture
30518                         SpriteSheetSize  [2]int16 // in sprites.
30519                         SpritePos        [2]int16 // in sprite sheet.
30520                         Visible          bool
30521                         MakeFootstepSnds bool
30522                         RotateSpeed      float32 // in radians per second.
30523                         Mesh             string
30524                         Colors           []color.NRGBA
30525                         CollideWithAOs   bool
30526                         StepHeight       float32
30527                         FaceRotateDir    bool
30528                         FaceRotateDirOff float32 // in degrees.
30529                         BackfaceCull     bool
30530                         Nametag          string
30531                         NametagColor     color.NRGBA
30532                         FaceRotateSpeed  float32 // in degrees per second.
30533                         Infotext         string
30534                         Itemstring       string
30535                         Glow             int8
30536                         MaxBreath        uint16  // Player only.
30537                         EyeHeight        float32 // Player only.
30538                         ZoomFOV          float32 // in degrees. Player only.
30539                         UseTextureAlpha  bool
30540                         DmgTextureMod    Texture // suffix
30541                         Shaded           bool
30542                         ShowOnMinimap    bool
30543                         NametagBG        color.NRGBA
30544                 }))(obj)).Glow
30545                 *p = int8(read8(r))
30546         }
30547         {
30548                 p := &(*(*(struct {
30549                         MaxHP            uint16 // Player only.
30550                         CollideWithNodes bool
30551                         Weight           float32 // deprecated
30552                         ColBox, SelBox   Box
30553                         Pointable        bool
30554                         Visual           string
30555                         VisualSize       [3]float32
30556                         Textures         []Texture
30557                         SpriteSheetSize  [2]int16 // in sprites.
30558                         SpritePos        [2]int16 // in sprite sheet.
30559                         Visible          bool
30560                         MakeFootstepSnds bool
30561                         RotateSpeed      float32 // in radians per second.
30562                         Mesh             string
30563                         Colors           []color.NRGBA
30564                         CollideWithAOs   bool
30565                         StepHeight       float32
30566                         FaceRotateDir    bool
30567                         FaceRotateDirOff float32 // in degrees.
30568                         BackfaceCull     bool
30569                         Nametag          string
30570                         NametagColor     color.NRGBA
30571                         FaceRotateSpeed  float32 // in degrees per second.
30572                         Infotext         string
30573                         Itemstring       string
30574                         Glow             int8
30575                         MaxBreath        uint16  // Player only.
30576                         EyeHeight        float32 // Player only.
30577                         ZoomFOV          float32 // in degrees. Player only.
30578                         UseTextureAlpha  bool
30579                         DmgTextureMod    Texture // suffix
30580                         Shaded           bool
30581                         ShowOnMinimap    bool
30582                         NametagBG        color.NRGBA
30583                 }))(obj)).MaxBreath
30584                 *p = read16(r)
30585         }
30586         {
30587                 p := &(*(*(struct {
30588                         MaxHP            uint16 // Player only.
30589                         CollideWithNodes bool
30590                         Weight           float32 // deprecated
30591                         ColBox, SelBox   Box
30592                         Pointable        bool
30593                         Visual           string
30594                         VisualSize       [3]float32
30595                         Textures         []Texture
30596                         SpriteSheetSize  [2]int16 // in sprites.
30597                         SpritePos        [2]int16 // in sprite sheet.
30598                         Visible          bool
30599                         MakeFootstepSnds bool
30600                         RotateSpeed      float32 // in radians per second.
30601                         Mesh             string
30602                         Colors           []color.NRGBA
30603                         CollideWithAOs   bool
30604                         StepHeight       float32
30605                         FaceRotateDir    bool
30606                         FaceRotateDirOff float32 // in degrees.
30607                         BackfaceCull     bool
30608                         Nametag          string
30609                         NametagColor     color.NRGBA
30610                         FaceRotateSpeed  float32 // in degrees per second.
30611                         Infotext         string
30612                         Itemstring       string
30613                         Glow             int8
30614                         MaxBreath        uint16  // Player only.
30615                         EyeHeight        float32 // Player only.
30616                         ZoomFOV          float32 // in degrees. Player only.
30617                         UseTextureAlpha  bool
30618                         DmgTextureMod    Texture // suffix
30619                         Shaded           bool
30620                         ShowOnMinimap    bool
30621                         NametagBG        color.NRGBA
30622                 }))(obj)).EyeHeight
30623                 *p = math.Float32frombits(read32(r))
30624         }
30625         {
30626                 p := &(*(*(struct {
30627                         MaxHP            uint16 // Player only.
30628                         CollideWithNodes bool
30629                         Weight           float32 // deprecated
30630                         ColBox, SelBox   Box
30631                         Pointable        bool
30632                         Visual           string
30633                         VisualSize       [3]float32
30634                         Textures         []Texture
30635                         SpriteSheetSize  [2]int16 // in sprites.
30636                         SpritePos        [2]int16 // in sprite sheet.
30637                         Visible          bool
30638                         MakeFootstepSnds bool
30639                         RotateSpeed      float32 // in radians per second.
30640                         Mesh             string
30641                         Colors           []color.NRGBA
30642                         CollideWithAOs   bool
30643                         StepHeight       float32
30644                         FaceRotateDir    bool
30645                         FaceRotateDirOff float32 // in degrees.
30646                         BackfaceCull     bool
30647                         Nametag          string
30648                         NametagColor     color.NRGBA
30649                         FaceRotateSpeed  float32 // in degrees per second.
30650                         Infotext         string
30651                         Itemstring       string
30652                         Glow             int8
30653                         MaxBreath        uint16  // Player only.
30654                         EyeHeight        float32 // Player only.
30655                         ZoomFOV          float32 // in degrees. Player only.
30656                         UseTextureAlpha  bool
30657                         DmgTextureMod    Texture // suffix
30658                         Shaded           bool
30659                         ShowOnMinimap    bool
30660                         NametagBG        color.NRGBA
30661                 }))(obj)).ZoomFOV
30662                 *p = math.Float32frombits(read32(r))
30663         }
30664         {
30665                 p := &(*(*(struct {
30666                         MaxHP            uint16 // Player only.
30667                         CollideWithNodes bool
30668                         Weight           float32 // deprecated
30669                         ColBox, SelBox   Box
30670                         Pointable        bool
30671                         Visual           string
30672                         VisualSize       [3]float32
30673                         Textures         []Texture
30674                         SpriteSheetSize  [2]int16 // in sprites.
30675                         SpritePos        [2]int16 // in sprite sheet.
30676                         Visible          bool
30677                         MakeFootstepSnds bool
30678                         RotateSpeed      float32 // in radians per second.
30679                         Mesh             string
30680                         Colors           []color.NRGBA
30681                         CollideWithAOs   bool
30682                         StepHeight       float32
30683                         FaceRotateDir    bool
30684                         FaceRotateDirOff float32 // in degrees.
30685                         BackfaceCull     bool
30686                         Nametag          string
30687                         NametagColor     color.NRGBA
30688                         FaceRotateSpeed  float32 // in degrees per second.
30689                         Infotext         string
30690                         Itemstring       string
30691                         Glow             int8
30692                         MaxBreath        uint16  // Player only.
30693                         EyeHeight        float32 // Player only.
30694                         ZoomFOV          float32 // in degrees. Player only.
30695                         UseTextureAlpha  bool
30696                         DmgTextureMod    Texture // suffix
30697                         Shaded           bool
30698                         ShowOnMinimap    bool
30699                         NametagBG        color.NRGBA
30700                 }))(obj)).UseTextureAlpha
30701                 switch n := read8(r); n {
30702                 case 0:
30703                         *p = false
30704                 case 1:
30705                         *p = true
30706                 default:
30707                         chk(fmt.Errorf("invalid bool: %d", n))
30708                 }
30709
30710         }
30711         if err := pcall(func() {
30712                 ((*(*(struct {
30713                         MaxHP            uint16 // Player only.
30714                         CollideWithNodes bool
30715                         Weight           float32 // deprecated
30716                         ColBox, SelBox   Box
30717                         Pointable        bool
30718                         Visual           string
30719                         VisualSize       [3]float32
30720                         Textures         []Texture
30721                         SpriteSheetSize  [2]int16 // in sprites.
30722                         SpritePos        [2]int16 // in sprite sheet.
30723                         Visible          bool
30724                         MakeFootstepSnds bool
30725                         RotateSpeed      float32 // in radians per second.
30726                         Mesh             string
30727                         Colors           []color.NRGBA
30728                         CollideWithAOs   bool
30729                         StepHeight       float32
30730                         FaceRotateDir    bool
30731                         FaceRotateDirOff float32 // in degrees.
30732                         BackfaceCull     bool
30733                         Nametag          string
30734                         NametagColor     color.NRGBA
30735                         FaceRotateSpeed  float32 // in degrees per second.
30736                         Infotext         string
30737                         Itemstring       string
30738                         Glow             int8
30739                         MaxBreath        uint16  // Player only.
30740                         EyeHeight        float32 // Player only.
30741                         ZoomFOV          float32 // in degrees. Player only.
30742                         UseTextureAlpha  bool
30743                         DmgTextureMod    Texture // suffix
30744                         Shaded           bool
30745                         ShowOnMinimap    bool
30746                         NametagBG        color.NRGBA
30747                 }))(obj)).DmgTextureMod).deserialize(r)
30748         }); err != nil {
30749                 if err == io.EOF {
30750                         chk(io.EOF)
30751                 }
30752                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
30753         }
30754         {
30755                 p := &(*(*(struct {
30756                         MaxHP            uint16 // Player only.
30757                         CollideWithNodes bool
30758                         Weight           float32 // deprecated
30759                         ColBox, SelBox   Box
30760                         Pointable        bool
30761                         Visual           string
30762                         VisualSize       [3]float32
30763                         Textures         []Texture
30764                         SpriteSheetSize  [2]int16 // in sprites.
30765                         SpritePos        [2]int16 // in sprite sheet.
30766                         Visible          bool
30767                         MakeFootstepSnds bool
30768                         RotateSpeed      float32 // in radians per second.
30769                         Mesh             string
30770                         Colors           []color.NRGBA
30771                         CollideWithAOs   bool
30772                         StepHeight       float32
30773                         FaceRotateDir    bool
30774                         FaceRotateDirOff float32 // in degrees.
30775                         BackfaceCull     bool
30776                         Nametag          string
30777                         NametagColor     color.NRGBA
30778                         FaceRotateSpeed  float32 // in degrees per second.
30779                         Infotext         string
30780                         Itemstring       string
30781                         Glow             int8
30782                         MaxBreath        uint16  // Player only.
30783                         EyeHeight        float32 // Player only.
30784                         ZoomFOV          float32 // in degrees. Player only.
30785                         UseTextureAlpha  bool
30786                         DmgTextureMod    Texture // suffix
30787                         Shaded           bool
30788                         ShowOnMinimap    bool
30789                         NametagBG        color.NRGBA
30790                 }))(obj)).Shaded
30791                 switch n := read8(r); n {
30792                 case 0:
30793                         *p = false
30794                 case 1:
30795                         *p = true
30796                 default:
30797                         chk(fmt.Errorf("invalid bool: %d", n))
30798                 }
30799
30800         }
30801         {
30802                 p := &(*(*(struct {
30803                         MaxHP            uint16 // Player only.
30804                         CollideWithNodes bool
30805                         Weight           float32 // deprecated
30806                         ColBox, SelBox   Box
30807                         Pointable        bool
30808                         Visual           string
30809                         VisualSize       [3]float32
30810                         Textures         []Texture
30811                         SpriteSheetSize  [2]int16 // in sprites.
30812                         SpritePos        [2]int16 // in sprite sheet.
30813                         Visible          bool
30814                         MakeFootstepSnds bool
30815                         RotateSpeed      float32 // in radians per second.
30816                         Mesh             string
30817                         Colors           []color.NRGBA
30818                         CollideWithAOs   bool
30819                         StepHeight       float32
30820                         FaceRotateDir    bool
30821                         FaceRotateDirOff float32 // in degrees.
30822                         BackfaceCull     bool
30823                         Nametag          string
30824                         NametagColor     color.NRGBA
30825                         FaceRotateSpeed  float32 // in degrees per second.
30826                         Infotext         string
30827                         Itemstring       string
30828                         Glow             int8
30829                         MaxBreath        uint16  // Player only.
30830                         EyeHeight        float32 // Player only.
30831                         ZoomFOV          float32 // in degrees. Player only.
30832                         UseTextureAlpha  bool
30833                         DmgTextureMod    Texture // suffix
30834                         Shaded           bool
30835                         ShowOnMinimap    bool
30836                         NametagBG        color.NRGBA
30837                 }))(obj)).ShowOnMinimap
30838                 switch n := read8(r); n {
30839                 case 0:
30840                         *p = false
30841                 case 1:
30842                         *p = true
30843                 default:
30844                         chk(fmt.Errorf("invalid bool: %d", n))
30845                 }
30846
30847         }
30848         {
30849                 p := &(*(*(struct {
30850                         MaxHP            uint16 // Player only.
30851                         CollideWithNodes bool
30852                         Weight           float32 // deprecated
30853                         ColBox, SelBox   Box
30854                         Pointable        bool
30855                         Visual           string
30856                         VisualSize       [3]float32
30857                         Textures         []Texture
30858                         SpriteSheetSize  [2]int16 // in sprites.
30859                         SpritePos        [2]int16 // in sprite sheet.
30860                         Visible          bool
30861                         MakeFootstepSnds bool
30862                         RotateSpeed      float32 // in radians per second.
30863                         Mesh             string
30864                         Colors           []color.NRGBA
30865                         CollideWithAOs   bool
30866                         StepHeight       float32
30867                         FaceRotateDir    bool
30868                         FaceRotateDirOff float32 // in degrees.
30869                         BackfaceCull     bool
30870                         Nametag          string
30871                         NametagColor     color.NRGBA
30872                         FaceRotateSpeed  float32 // in degrees per second.
30873                         Infotext         string
30874                         Itemstring       string
30875                         Glow             int8
30876                         MaxBreath        uint16  // Player only.
30877                         EyeHeight        float32 // Player only.
30878                         ZoomFOV          float32 // in degrees. Player only.
30879                         UseTextureAlpha  bool
30880                         DmgTextureMod    Texture // suffix
30881                         Shaded           bool
30882                         ShowOnMinimap    bool
30883                         NametagBG        color.NRGBA
30884                 }))(obj)).NametagBG
30885                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
30886
30887         }
30888 }
30889
30890 func (obj *AOPos) serialize(w io.Writer) {
30891         if err := pcall(func() {
30892                 ((*(*(struct {
30893                         Pos
30894                         Vel, Acc Vec
30895                         Rot      [3]float32
30896
30897                         Interpolate    bool
30898                         End            bool
30899                         UpdateInterval float32
30900                 }))(obj)).Pos).serialize(w)
30901         }); err != nil {
30902                 if err == io.EOF {
30903                         chk(io.EOF)
30904                 }
30905                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
30906         }
30907         if err := pcall(func() {
30908                 ((*(*(struct {
30909                         Pos
30910                         Vel, Acc Vec
30911                         Rot      [3]float32
30912
30913                         Interpolate    bool
30914                         End            bool
30915                         UpdateInterval float32
30916                 }))(obj)).Vel).serialize(w)
30917         }); err != nil {
30918                 if err == io.EOF {
30919                         chk(io.EOF)
30920                 }
30921                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
30922         }
30923         if err := pcall(func() {
30924                 ((*(*(struct {
30925                         Pos
30926                         Vel, Acc Vec
30927                         Rot      [3]float32
30928
30929                         Interpolate    bool
30930                         End            bool
30931                         UpdateInterval float32
30932                 }))(obj)).Acc).serialize(w)
30933         }); err != nil {
30934                 if err == io.EOF {
30935                         chk(io.EOF)
30936                 }
30937                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
30938         }
30939         for local358 := range (*(*(struct {
30940                 Pos
30941                 Vel, Acc Vec
30942                 Rot      [3]float32
30943
30944                 Interpolate    bool
30945                 End            bool
30946                 UpdateInterval float32
30947         }))(obj)).Rot {
30948                 {
30949                         x := ((*(*(struct {
30950                                 Pos
30951                                 Vel, Acc Vec
30952                                 Rot      [3]float32
30953
30954                                 Interpolate    bool
30955                                 End            bool
30956                                 UpdateInterval float32
30957                         }))(obj)).Rot)[local358]
30958                         write32(w, math.Float32bits(x))
30959                 }
30960         }
30961         {
30962                 x := (*(*(struct {
30963                         Pos
30964                         Vel, Acc Vec
30965                         Rot      [3]float32
30966
30967                         Interpolate    bool
30968                         End            bool
30969                         UpdateInterval float32
30970                 }))(obj)).Interpolate
30971                 if x {
30972                         write8(w, 1)
30973                 } else {
30974                         write8(w, 0)
30975                 }
30976
30977         }
30978         {
30979                 x := (*(*(struct {
30980                         Pos
30981                         Vel, Acc Vec
30982                         Rot      [3]float32
30983
30984                         Interpolate    bool
30985                         End            bool
30986                         UpdateInterval float32
30987                 }))(obj)).End
30988                 if x {
30989                         write8(w, 1)
30990                 } else {
30991                         write8(w, 0)
30992                 }
30993
30994         }
30995         {
30996                 x := (*(*(struct {
30997                         Pos
30998                         Vel, Acc Vec
30999                         Rot      [3]float32
31000
31001                         Interpolate    bool
31002                         End            bool
31003                         UpdateInterval float32
31004                 }))(obj)).UpdateInterval
31005                 write32(w, math.Float32bits(x))
31006         }
31007 }
31008
31009 func (obj *AOPos) deserialize(r io.Reader) {
31010         if err := pcall(func() {
31011                 ((*(*(struct {
31012                         Pos
31013                         Vel, Acc Vec
31014                         Rot      [3]float32
31015
31016                         Interpolate    bool
31017                         End            bool
31018                         UpdateInterval float32
31019                 }))(obj)).Pos).deserialize(r)
31020         }); err != nil {
31021                 if err == io.EOF {
31022                         chk(io.EOF)
31023                 }
31024                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
31025         }
31026         if err := pcall(func() {
31027                 ((*(*(struct {
31028                         Pos
31029                         Vel, Acc Vec
31030                         Rot      [3]float32
31031
31032                         Interpolate    bool
31033                         End            bool
31034                         UpdateInterval float32
31035                 }))(obj)).Vel).deserialize(r)
31036         }); err != nil {
31037                 if err == io.EOF {
31038                         chk(io.EOF)
31039                 }
31040                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31041         }
31042         if err := pcall(func() {
31043                 ((*(*(struct {
31044                         Pos
31045                         Vel, Acc Vec
31046                         Rot      [3]float32
31047
31048                         Interpolate    bool
31049                         End            bool
31050                         UpdateInterval float32
31051                 }))(obj)).Acc).deserialize(r)
31052         }); err != nil {
31053                 if err == io.EOF {
31054                         chk(io.EOF)
31055                 }
31056                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31057         }
31058         for local359 := range (*(*(struct {
31059                 Pos
31060                 Vel, Acc Vec
31061                 Rot      [3]float32
31062
31063                 Interpolate    bool
31064                 End            bool
31065                 UpdateInterval float32
31066         }))(obj)).Rot {
31067                 {
31068                         p := &((*(*(struct {
31069                                 Pos
31070                                 Vel, Acc Vec
31071                                 Rot      [3]float32
31072
31073                                 Interpolate    bool
31074                                 End            bool
31075                                 UpdateInterval float32
31076                         }))(obj)).Rot)[local359]
31077                         *p = math.Float32frombits(read32(r))
31078                 }
31079         }
31080         {
31081                 p := &(*(*(struct {
31082                         Pos
31083                         Vel, Acc Vec
31084                         Rot      [3]float32
31085
31086                         Interpolate    bool
31087                         End            bool
31088                         UpdateInterval float32
31089                 }))(obj)).Interpolate
31090                 switch n := read8(r); n {
31091                 case 0:
31092                         *p = false
31093                 case 1:
31094                         *p = true
31095                 default:
31096                         chk(fmt.Errorf("invalid bool: %d", n))
31097                 }
31098
31099         }
31100         {
31101                 p := &(*(*(struct {
31102                         Pos
31103                         Vel, Acc Vec
31104                         Rot      [3]float32
31105
31106                         Interpolate    bool
31107                         End            bool
31108                         UpdateInterval float32
31109                 }))(obj)).End
31110                 switch n := read8(r); n {
31111                 case 0:
31112                         *p = false
31113                 case 1:
31114                         *p = true
31115                 default:
31116                         chk(fmt.Errorf("invalid bool: %d", n))
31117                 }
31118
31119         }
31120         {
31121                 p := &(*(*(struct {
31122                         Pos
31123                         Vel, Acc Vec
31124                         Rot      [3]float32
31125
31126                         Interpolate    bool
31127                         End            bool
31128                         UpdateInterval float32
31129                 }))(obj)).UpdateInterval
31130                 *p = math.Float32frombits(read32(r))
31131         }
31132 }
31133
31134 func (obj *AOSprite) serialize(w io.Writer) {
31135         for local360 := range (*(*(struct {
31136                 Frame0          [2]int16
31137                 Frames          uint16
31138                 FrameDuration   float32
31139                 ViewAngleFrames bool
31140         }))(obj)).Frame0 {
31141                 {
31142                         x := ((*(*(struct {
31143                                 Frame0          [2]int16
31144                                 Frames          uint16
31145                                 FrameDuration   float32
31146                                 ViewAngleFrames bool
31147                         }))(obj)).Frame0)[local360]
31148                         write16(w, uint16(x))
31149                 }
31150         }
31151         {
31152                 x := (*(*(struct {
31153                         Frame0          [2]int16
31154                         Frames          uint16
31155                         FrameDuration   float32
31156                         ViewAngleFrames bool
31157                 }))(obj)).Frames
31158                 write16(w, uint16(x))
31159         }
31160         {
31161                 x := (*(*(struct {
31162                         Frame0          [2]int16
31163                         Frames          uint16
31164                         FrameDuration   float32
31165                         ViewAngleFrames bool
31166                 }))(obj)).FrameDuration
31167                 write32(w, math.Float32bits(x))
31168         }
31169         {
31170                 x := (*(*(struct {
31171                         Frame0          [2]int16
31172                         Frames          uint16
31173                         FrameDuration   float32
31174                         ViewAngleFrames bool
31175                 }))(obj)).ViewAngleFrames
31176                 if x {
31177                         write8(w, 1)
31178                 } else {
31179                         write8(w, 0)
31180                 }
31181
31182         }
31183 }
31184
31185 func (obj *AOSprite) deserialize(r io.Reader) {
31186         for local361 := range (*(*(struct {
31187                 Frame0          [2]int16
31188                 Frames          uint16
31189                 FrameDuration   float32
31190                 ViewAngleFrames bool
31191         }))(obj)).Frame0 {
31192                 {
31193                         p := &((*(*(struct {
31194                                 Frame0          [2]int16
31195                                 Frames          uint16
31196                                 FrameDuration   float32
31197                                 ViewAngleFrames bool
31198                         }))(obj)).Frame0)[local361]
31199                         *p = int16(read16(r))
31200                 }
31201         }
31202         {
31203                 p := &(*(*(struct {
31204                         Frame0          [2]int16
31205                         Frames          uint16
31206                         FrameDuration   float32
31207                         ViewAngleFrames bool
31208                 }))(obj)).Frames
31209                 *p = read16(r)
31210         }
31211         {
31212                 p := &(*(*(struct {
31213                         Frame0          [2]int16
31214                         Frames          uint16
31215                         FrameDuration   float32
31216                         ViewAngleFrames bool
31217                 }))(obj)).FrameDuration
31218                 *p = math.Float32frombits(read32(r))
31219         }
31220         {
31221                 p := &(*(*(struct {
31222                         Frame0          [2]int16
31223                         Frames          uint16
31224                         FrameDuration   float32
31225                         ViewAngleFrames bool
31226                 }))(obj)).ViewAngleFrames
31227                 switch n := read8(r); n {
31228                 case 0:
31229                         *p = false
31230                 case 1:
31231                         *p = true
31232                 default:
31233                         chk(fmt.Errorf("invalid bool: %d", n))
31234                 }
31235
31236         }
31237 }
31238
31239 func (obj *Group) serialize(w io.Writer) {
31240         if len(([]byte((*(*(struct {
31241                 Name   string
31242                 Rating int16
31243         }))(obj)).Name))) > math.MaxUint16 {
31244                 chk(ErrTooLong)
31245         }
31246         {
31247                 x := uint16(len(([]byte((*(*(struct {
31248                         Name   string
31249                         Rating int16
31250                 }))(obj)).Name))))
31251                 write16(w, uint16(x))
31252         }
31253         {
31254                 _, err := w.Write(([]byte((*(*(struct {
31255                         Name   string
31256                         Rating int16
31257                 }))(obj)).Name))[:])
31258                 chk(err)
31259         }
31260         {
31261                 x := (*(*(struct {
31262                         Name   string
31263                         Rating int16
31264                 }))(obj)).Rating
31265                 write16(w, uint16(x))
31266         }
31267 }
31268
31269 func (obj *Group) deserialize(r io.Reader) {
31270         var local362 []uint8
31271         var local363 uint16
31272         {
31273                 p := &local363
31274                 *p = read16(r)
31275         }
31276         (local362) = make([]uint8, local363)
31277         {
31278                 _, err := io.ReadFull(r, (local362)[:])
31279                 chk(err)
31280         }
31281         ((*(*(struct {
31282                 Name   string
31283                 Rating int16
31284         }))(obj)).Name) = string(local362)
31285         {
31286                 p := &(*(*(struct {
31287                         Name   string
31288                         Rating int16
31289                 }))(obj)).Rating
31290                 *p = int16(read16(r))
31291         }
31292 }
31293
31294 func (obj *AOAnim) serialize(w io.Writer) {
31295         for local364 := range (*(*(struct {
31296                 Frames [2]int32
31297                 Speed  float32
31298                 Blend  float32
31299                 NoLoop bool
31300         }))(obj)).Frames {
31301                 {
31302                         x := ((*(*(struct {
31303                                 Frames [2]int32
31304                                 Speed  float32
31305                                 Blend  float32
31306                                 NoLoop bool
31307                         }))(obj)).Frames)[local364]
31308                         write32(w, uint32(x))
31309                 }
31310         }
31311         {
31312                 x := (*(*(struct {
31313                         Frames [2]int32
31314                         Speed  float32
31315                         Blend  float32
31316                         NoLoop bool
31317                 }))(obj)).Speed
31318                 write32(w, math.Float32bits(x))
31319         }
31320         {
31321                 x := (*(*(struct {
31322                         Frames [2]int32
31323                         Speed  float32
31324                         Blend  float32
31325                         NoLoop bool
31326                 }))(obj)).Blend
31327                 write32(w, math.Float32bits(x))
31328         }
31329         {
31330                 x := (*(*(struct {
31331                         Frames [2]int32
31332                         Speed  float32
31333                         Blend  float32
31334                         NoLoop bool
31335                 }))(obj)).NoLoop
31336                 if x {
31337                         write8(w, 1)
31338                 } else {
31339                         write8(w, 0)
31340                 }
31341
31342         }
31343 }
31344
31345 func (obj *AOAnim) deserialize(r io.Reader) {
31346         for local365 := range (*(*(struct {
31347                 Frames [2]int32
31348                 Speed  float32
31349                 Blend  float32
31350                 NoLoop bool
31351         }))(obj)).Frames {
31352                 {
31353                         p := &((*(*(struct {
31354                                 Frames [2]int32
31355                                 Speed  float32
31356                                 Blend  float32
31357                                 NoLoop bool
31358                         }))(obj)).Frames)[local365]
31359                         *p = int32(read32(r))
31360                 }
31361         }
31362         {
31363                 p := &(*(*(struct {
31364                         Frames [2]int32
31365                         Speed  float32
31366                         Blend  float32
31367                         NoLoop bool
31368                 }))(obj)).Speed
31369                 *p = math.Float32frombits(read32(r))
31370         }
31371         {
31372                 p := &(*(*(struct {
31373                         Frames [2]int32
31374                         Speed  float32
31375                         Blend  float32
31376                         NoLoop bool
31377                 }))(obj)).Blend
31378                 *p = math.Float32frombits(read32(r))
31379         }
31380         {
31381                 p := &(*(*(struct {
31382                         Frames [2]int32
31383                         Speed  float32
31384                         Blend  float32
31385                         NoLoop bool
31386                 }))(obj)).NoLoop
31387                 switch n := read8(r); n {
31388                 case 0:
31389                         *p = false
31390                 case 1:
31391                         *p = true
31392                 default:
31393                         chk(fmt.Errorf("invalid bool: %d", n))
31394                 }
31395
31396         }
31397 }
31398
31399 func (obj *AOBonePos) serialize(w io.Writer) {
31400         if err := pcall(func() {
31401                 ((*(*(struct {
31402                         Pos Vec
31403                         Rot [3]float32
31404                 }))(obj)).Pos).serialize(w)
31405         }); err != nil {
31406                 if err == io.EOF {
31407                         chk(io.EOF)
31408                 }
31409                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31410         }
31411         for local366 := range (*(*(struct {
31412                 Pos Vec
31413                 Rot [3]float32
31414         }))(obj)).Rot {
31415                 {
31416                         x := ((*(*(struct {
31417                                 Pos Vec
31418                                 Rot [3]float32
31419                         }))(obj)).Rot)[local366]
31420                         write32(w, math.Float32bits(x))
31421                 }
31422         }
31423 }
31424
31425 func (obj *AOBonePos) deserialize(r io.Reader) {
31426         if err := pcall(func() {
31427                 ((*(*(struct {
31428                         Pos Vec
31429                         Rot [3]float32
31430                 }))(obj)).Pos).deserialize(r)
31431         }); err != nil {
31432                 if err == io.EOF {
31433                         chk(io.EOF)
31434                 }
31435                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31436         }
31437         for local367 := range (*(*(struct {
31438                 Pos Vec
31439                 Rot [3]float32
31440         }))(obj)).Rot {
31441                 {
31442                         p := &((*(*(struct {
31443                                 Pos Vec
31444                                 Rot [3]float32
31445                         }))(obj)).Rot)[local367]
31446                         *p = math.Float32frombits(read32(r))
31447                 }
31448         }
31449 }
31450
31451 func (obj *AOAttach) serialize(w io.Writer) {
31452         if err := pcall(func() {
31453                 ((*(*(struct {
31454                         ParentID     AOID
31455                         Bone         string
31456                         Pos          Vec
31457                         Rot          [3]float32
31458                         ForceVisible bool
31459                 }))(obj)).ParentID).serialize(w)
31460         }); err != nil {
31461                 if err == io.EOF {
31462                         chk(io.EOF)
31463                 }
31464                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
31465         }
31466         if len(([]byte((*(*(struct {
31467                 ParentID     AOID
31468                 Bone         string
31469                 Pos          Vec
31470                 Rot          [3]float32
31471                 ForceVisible bool
31472         }))(obj)).Bone))) > math.MaxUint16 {
31473                 chk(ErrTooLong)
31474         }
31475         {
31476                 x := uint16(len(([]byte((*(*(struct {
31477                         ParentID     AOID
31478                         Bone         string
31479                         Pos          Vec
31480                         Rot          [3]float32
31481                         ForceVisible bool
31482                 }))(obj)).Bone))))
31483                 write16(w, uint16(x))
31484         }
31485         {
31486                 _, err := w.Write(([]byte((*(*(struct {
31487                         ParentID     AOID
31488                         Bone         string
31489                         Pos          Vec
31490                         Rot          [3]float32
31491                         ForceVisible bool
31492                 }))(obj)).Bone))[:])
31493                 chk(err)
31494         }
31495         if err := pcall(func() {
31496                 ((*(*(struct {
31497                         ParentID     AOID
31498                         Bone         string
31499                         Pos          Vec
31500                         Rot          [3]float32
31501                         ForceVisible bool
31502                 }))(obj)).Pos).serialize(w)
31503         }); err != nil {
31504                 if err == io.EOF {
31505                         chk(io.EOF)
31506                 }
31507                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31508         }
31509         for local368 := range (*(*(struct {
31510                 ParentID     AOID
31511                 Bone         string
31512                 Pos          Vec
31513                 Rot          [3]float32
31514                 ForceVisible bool
31515         }))(obj)).Rot {
31516                 {
31517                         x := ((*(*(struct {
31518                                 ParentID     AOID
31519                                 Bone         string
31520                                 Pos          Vec
31521                                 Rot          [3]float32
31522                                 ForceVisible bool
31523                         }))(obj)).Rot)[local368]
31524                         write32(w, math.Float32bits(x))
31525                 }
31526         }
31527         {
31528                 x := (*(*(struct {
31529                         ParentID     AOID
31530                         Bone         string
31531                         Pos          Vec
31532                         Rot          [3]float32
31533                         ForceVisible bool
31534                 }))(obj)).ForceVisible
31535                 if x {
31536                         write8(w, 1)
31537                 } else {
31538                         write8(w, 0)
31539                 }
31540
31541         }
31542 }
31543
31544 func (obj *AOAttach) deserialize(r io.Reader) {
31545         if err := pcall(func() {
31546                 ((*(*(struct {
31547                         ParentID     AOID
31548                         Bone         string
31549                         Pos          Vec
31550                         Rot          [3]float32
31551                         ForceVisible bool
31552                 }))(obj)).ParentID).deserialize(r)
31553         }); err != nil {
31554                 if err == io.EOF {
31555                         chk(io.EOF)
31556                 }
31557                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
31558         }
31559         var local369 []uint8
31560         var local370 uint16
31561         {
31562                 p := &local370
31563                 *p = read16(r)
31564         }
31565         (local369) = make([]uint8, local370)
31566         {
31567                 _, err := io.ReadFull(r, (local369)[:])
31568                 chk(err)
31569         }
31570         ((*(*(struct {
31571                 ParentID     AOID
31572                 Bone         string
31573                 Pos          Vec
31574                 Rot          [3]float32
31575                 ForceVisible bool
31576         }))(obj)).Bone) = string(local369)
31577         if err := pcall(func() {
31578                 ((*(*(struct {
31579                         ParentID     AOID
31580                         Bone         string
31581                         Pos          Vec
31582                         Rot          [3]float32
31583                         ForceVisible bool
31584                 }))(obj)).Pos).deserialize(r)
31585         }); err != nil {
31586                 if err == io.EOF {
31587                         chk(io.EOF)
31588                 }
31589                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
31590         }
31591         for local371 := range (*(*(struct {
31592                 ParentID     AOID
31593                 Bone         string
31594                 Pos          Vec
31595                 Rot          [3]float32
31596                 ForceVisible bool
31597         }))(obj)).Rot {
31598                 {
31599                         p := &((*(*(struct {
31600                                 ParentID     AOID
31601                                 Bone         string
31602                                 Pos          Vec
31603                                 Rot          [3]float32
31604                                 ForceVisible bool
31605                         }))(obj)).Rot)[local371]
31606                         *p = math.Float32frombits(read32(r))
31607                 }
31608         }
31609         {
31610                 p := &(*(*(struct {
31611                         ParentID     AOID
31612                         Bone         string
31613                         Pos          Vec
31614                         Rot          [3]float32
31615                         ForceVisible bool
31616                 }))(obj)).ForceVisible
31617                 switch n := read8(r); n {
31618                 case 0:
31619                         *p = false
31620                 case 1:
31621                         *p = true
31622                 default:
31623                         chk(fmt.Errorf("invalid bool: %d", n))
31624                 }
31625
31626         }
31627 }
31628
31629 func (obj *AOPhysOverride) serialize(w io.Writer) {
31630         {
31631                 x := (*(*(struct {
31632                         Walk, Jump, Gravity float32
31633
31634                         // Player only.
31635                         NoSneak, NoSneakGlitch, OldSneak bool
31636                 }))(obj)).Walk
31637                 write32(w, math.Float32bits(x))
31638         }
31639         {
31640                 x := (*(*(struct {
31641                         Walk, Jump, Gravity float32
31642
31643                         // Player only.
31644                         NoSneak, NoSneakGlitch, OldSneak bool
31645                 }))(obj)).Jump
31646                 write32(w, math.Float32bits(x))
31647         }
31648         {
31649                 x := (*(*(struct {
31650                         Walk, Jump, Gravity float32
31651
31652                         // Player only.
31653                         NoSneak, NoSneakGlitch, OldSneak bool
31654                 }))(obj)).Gravity
31655                 write32(w, math.Float32bits(x))
31656         }
31657         {
31658                 x := (*(*(struct {
31659                         Walk, Jump, Gravity float32
31660
31661                         // Player only.
31662                         NoSneak, NoSneakGlitch, OldSneak bool
31663                 }))(obj)).NoSneak
31664                 if x {
31665                         write8(w, 1)
31666                 } else {
31667                         write8(w, 0)
31668                 }
31669
31670         }
31671         {
31672                 x := (*(*(struct {
31673                         Walk, Jump, Gravity float32
31674
31675                         // Player only.
31676                         NoSneak, NoSneakGlitch, OldSneak bool
31677                 }))(obj)).NoSneakGlitch
31678                 if x {
31679                         write8(w, 1)
31680                 } else {
31681                         write8(w, 0)
31682                 }
31683
31684         }
31685         {
31686                 x := (*(*(struct {
31687                         Walk, Jump, Gravity float32
31688
31689                         // Player only.
31690                         NoSneak, NoSneakGlitch, OldSneak bool
31691                 }))(obj)).OldSneak
31692                 if x {
31693                         write8(w, 1)
31694                 } else {
31695                         write8(w, 0)
31696                 }
31697
31698         }
31699 }
31700
31701 func (obj *AOPhysOverride) deserialize(r io.Reader) {
31702         {
31703                 p := &(*(*(struct {
31704                         Walk, Jump, Gravity float32
31705
31706                         // Player only.
31707                         NoSneak, NoSneakGlitch, OldSneak bool
31708                 }))(obj)).Walk
31709                 *p = math.Float32frombits(read32(r))
31710         }
31711         {
31712                 p := &(*(*(struct {
31713                         Walk, Jump, Gravity float32
31714
31715                         // Player only.
31716                         NoSneak, NoSneakGlitch, OldSneak bool
31717                 }))(obj)).Jump
31718                 *p = math.Float32frombits(read32(r))
31719         }
31720         {
31721                 p := &(*(*(struct {
31722                         Walk, Jump, Gravity float32
31723
31724                         // Player only.
31725                         NoSneak, NoSneakGlitch, OldSneak bool
31726                 }))(obj)).Gravity
31727                 *p = math.Float32frombits(read32(r))
31728         }
31729         {
31730                 p := &(*(*(struct {
31731                         Walk, Jump, Gravity float32
31732
31733                         // Player only.
31734                         NoSneak, NoSneakGlitch, OldSneak bool
31735                 }))(obj)).NoSneak
31736                 switch n := read8(r); n {
31737                 case 0:
31738                         *p = false
31739                 case 1:
31740                         *p = true
31741                 default:
31742                         chk(fmt.Errorf("invalid bool: %d", n))
31743                 }
31744
31745         }
31746         {
31747                 p := &(*(*(struct {
31748                         Walk, Jump, Gravity float32
31749
31750                         // Player only.
31751                         NoSneak, NoSneakGlitch, OldSneak bool
31752                 }))(obj)).NoSneakGlitch
31753                 switch n := read8(r); n {
31754                 case 0:
31755                         *p = false
31756                 case 1:
31757                         *p = true
31758                 default:
31759                         chk(fmt.Errorf("invalid bool: %d", n))
31760                 }
31761
31762         }
31763         {
31764                 p := &(*(*(struct {
31765                         Walk, Jump, Gravity float32
31766
31767                         // Player only.
31768                         NoSneak, NoSneakGlitch, OldSneak bool
31769                 }))(obj)).OldSneak
31770                 switch n := read8(r); n {
31771                 case 0:
31772                         *p = false
31773                 case 1:
31774                         *p = true
31775                 default:
31776                         chk(fmt.Errorf("invalid bool: %d", n))
31777                 }
31778
31779         }
31780 }
31781
31782 func (obj *aoType) serialize(w io.Writer) {
31783         {
31784                 x := *(*(uint8))(obj)
31785                 write8(w, uint8(x))
31786         }
31787 }
31788
31789 func (obj *aoType) deserialize(r io.Reader) {
31790         {
31791                 p := &*(*(uint8))(obj)
31792                 *p = read8(r)
31793         }
31794 }
31795
31796 func (obj *NodeMetaField) serialize(w io.Writer) {
31797         if err := pcall(func() {
31798                 ((*(*(struct {
31799                         Field
31800                         Private bool
31801                 }))(obj)).Field).serialize(w)
31802         }); err != nil {
31803                 if err == io.EOF {
31804                         chk(io.EOF)
31805                 }
31806                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
31807         }
31808         {
31809                 x := (*(*(struct {
31810                         Field
31811                         Private bool
31812                 }))(obj)).Private
31813                 if x {
31814                         write8(w, 1)
31815                 } else {
31816                         write8(w, 0)
31817                 }
31818
31819         }
31820 }
31821
31822 func (obj *NodeMetaField) deserialize(r io.Reader) {
31823         if err := pcall(func() {
31824                 ((*(*(struct {
31825                         Field
31826                         Private bool
31827                 }))(obj)).Field).deserialize(r)
31828         }); err != nil {
31829                 if err == io.EOF {
31830                         chk(io.EOF)
31831                 }
31832                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Field", err))
31833         }
31834         {
31835                 p := &(*(*(struct {
31836                         Field
31837                         Private bool
31838                 }))(obj)).Private
31839                 switch n := read8(r); n {
31840                 case 0:
31841                         *p = false
31842                 case 1:
31843                         *p = true
31844                 default:
31845                         chk(fmt.Errorf("invalid bool: %d", n))
31846                 }
31847
31848         }
31849 }
31850
31851 func (obj *MinimapType) serialize(w io.Writer) {
31852         {
31853                 x := *(*(uint16))(obj)
31854                 write16(w, uint16(x))
31855         }
31856 }
31857
31858 func (obj *MinimapType) deserialize(r io.Reader) {
31859         {
31860                 p := &*(*(uint16))(obj)
31861                 *p = read16(r)
31862         }
31863 }
31864
31865 func (obj *Param1Type) serialize(w io.Writer) {
31866         {
31867                 x := *(*(uint8))(obj)
31868                 write8(w, uint8(x))
31869         }
31870 }
31871
31872 func (obj *Param1Type) deserialize(r io.Reader) {
31873         {
31874                 p := &*(*(uint8))(obj)
31875                 *p = read8(r)
31876         }
31877 }
31878
31879 func (obj *Param2Type) serialize(w io.Writer) {
31880         {
31881                 x := *(*(uint8))(obj)
31882                 write8(w, uint8(x))
31883         }
31884 }
31885
31886 func (obj *Param2Type) deserialize(r io.Reader) {
31887         {
31888                 p := &*(*(uint8))(obj)
31889                 *p = read8(r)
31890         }
31891 }
31892
31893 func (obj *DrawType) serialize(w io.Writer) {
31894         {
31895                 x := *(*(uint8))(obj)
31896                 write8(w, uint8(x))
31897         }
31898 }
31899
31900 func (obj *DrawType) deserialize(r io.Reader) {
31901         {
31902                 p := &*(*(uint8))(obj)
31903                 *p = read8(r)
31904         }
31905 }
31906
31907 func (obj *TileDef) serialize(w io.Writer) {
31908         {
31909                 local372 := uint8(6)
31910                 {
31911                         x := local372
31912                         write8(w, uint8(x))
31913                 }
31914         }
31915         if err := pcall(func() {
31916                 ((*(*(struct {
31917                         Texture
31918                         Anim  TileAnim
31919                         Flags TileFlags
31920
31921                         //mt:if %s.Flags&TileColor != 0
31922                         R, G, B uint8
31923
31924                         //mt:if %s.Flags&TileScale != 0
31925                         Scale uint8
31926
31927                         //mt:if %s.Flags&TileAlign != 0
31928                         Align AlignType
31929                 }))(obj)).Texture).serialize(w)
31930         }); err != nil {
31931                 if err == io.EOF {
31932                         chk(io.EOF)
31933                 }
31934                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
31935         }
31936         if err := pcall(func() {
31937                 ((*(*(struct {
31938                         Texture
31939                         Anim  TileAnim
31940                         Flags TileFlags
31941
31942                         //mt:if %s.Flags&TileColor != 0
31943                         R, G, B uint8
31944
31945                         //mt:if %s.Flags&TileScale != 0
31946                         Scale uint8
31947
31948                         //mt:if %s.Flags&TileAlign != 0
31949                         Align AlignType
31950                 }))(obj)).Anim).serialize(w)
31951         }); err != nil {
31952                 if err == io.EOF {
31953                         chk(io.EOF)
31954                 }
31955                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
31956         }
31957         if err := pcall(func() {
31958                 ((*(*(struct {
31959                         Texture
31960                         Anim  TileAnim
31961                         Flags TileFlags
31962
31963                         //mt:if %s.Flags&TileColor != 0
31964                         R, G, B uint8
31965
31966                         //mt:if %s.Flags&TileScale != 0
31967                         Scale uint8
31968
31969                         //mt:if %s.Flags&TileAlign != 0
31970                         Align AlignType
31971                 }))(obj)).Flags).serialize(w)
31972         }); err != nil {
31973                 if err == io.EOF {
31974                         chk(io.EOF)
31975                 }
31976                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileFlags", err))
31977         }
31978         if (*(*(struct {
31979                 Texture
31980                 Anim  TileAnim
31981                 Flags TileFlags
31982
31983                 //mt:if %s.Flags&TileColor != 0
31984                 R, G, B uint8
31985
31986                 //mt:if %s.Flags&TileScale != 0
31987                 Scale uint8
31988
31989                 //mt:if %s.Flags&TileAlign != 0
31990                 Align AlignType
31991         }))(obj)).Flags&TileColor != 0 {
31992                 {
31993                         x := (*(*(struct {
31994                                 Texture
31995                                 Anim  TileAnim
31996                                 Flags TileFlags
31997
31998                                 //mt:if %s.Flags&TileColor != 0
31999                                 R, G, B uint8
32000
32001                                 //mt:if %s.Flags&TileScale != 0
32002                                 Scale uint8
32003
32004                                 //mt:if %s.Flags&TileAlign != 0
32005                                 Align AlignType
32006                         }))(obj)).R
32007                         write8(w, uint8(x))
32008                 }
32009                 {
32010                         x := (*(*(struct {
32011                                 Texture
32012                                 Anim  TileAnim
32013                                 Flags TileFlags
32014
32015                                 //mt:if %s.Flags&TileColor != 0
32016                                 R, G, B uint8
32017
32018                                 //mt:if %s.Flags&TileScale != 0
32019                                 Scale uint8
32020
32021                                 //mt:if %s.Flags&TileAlign != 0
32022                                 Align AlignType
32023                         }))(obj)).G
32024                         write8(w, uint8(x))
32025                 }
32026                 {
32027                         x := (*(*(struct {
32028                                 Texture
32029                                 Anim  TileAnim
32030                                 Flags TileFlags
32031
32032                                 //mt:if %s.Flags&TileColor != 0
32033                                 R, G, B uint8
32034
32035                                 //mt:if %s.Flags&TileScale != 0
32036                                 Scale uint8
32037
32038                                 //mt:if %s.Flags&TileAlign != 0
32039                                 Align AlignType
32040                         }))(obj)).B
32041                         write8(w, uint8(x))
32042                 }
32043         }
32044         if (*(*(struct {
32045                 Texture
32046                 Anim  TileAnim
32047                 Flags TileFlags
32048
32049                 //mt:if %s.Flags&TileColor != 0
32050                 R, G, B uint8
32051
32052                 //mt:if %s.Flags&TileScale != 0
32053                 Scale uint8
32054
32055                 //mt:if %s.Flags&TileAlign != 0
32056                 Align AlignType
32057         }))(obj)).Flags&TileScale != 0 {
32058                 {
32059                         x := (*(*(struct {
32060                                 Texture
32061                                 Anim  TileAnim
32062                                 Flags TileFlags
32063
32064                                 //mt:if %s.Flags&TileColor != 0
32065                                 R, G, B uint8
32066
32067                                 //mt:if %s.Flags&TileScale != 0
32068                                 Scale uint8
32069
32070                                 //mt:if %s.Flags&TileAlign != 0
32071                                 Align AlignType
32072                         }))(obj)).Scale
32073                         write8(w, uint8(x))
32074                 }
32075         }
32076         if (*(*(struct {
32077                 Texture
32078                 Anim  TileAnim
32079                 Flags TileFlags
32080
32081                 //mt:if %s.Flags&TileColor != 0
32082                 R, G, B uint8
32083
32084                 //mt:if %s.Flags&TileScale != 0
32085                 Scale uint8
32086
32087                 //mt:if %s.Flags&TileAlign != 0
32088                 Align AlignType
32089         }))(obj)).Flags&TileAlign != 0 {
32090                 if err := pcall(func() {
32091                         ((*(*(struct {
32092                                 Texture
32093                                 Anim  TileAnim
32094                                 Flags TileFlags
32095
32096                                 //mt:if %s.Flags&TileColor != 0
32097                                 R, G, B uint8
32098
32099                                 //mt:if %s.Flags&TileScale != 0
32100                                 Scale uint8
32101
32102                                 //mt:if %s.Flags&TileAlign != 0
32103                                 Align AlignType
32104                         }))(obj)).Align).serialize(w)
32105                 }); err != nil {
32106                         if err == io.EOF {
32107                                 chk(io.EOF)
32108                         }
32109                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlignType", err))
32110                 }
32111         }
32112 }
32113
32114 func (obj *TileDef) deserialize(r io.Reader) {
32115         {
32116                 var local373 uint8
32117                 local374 := uint8(6)
32118                 {
32119                         p := &local373
32120                         *p = read8(r)
32121                 }
32122                 if local373 != local374 {
32123                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local373))
32124                 }
32125         }
32126         if err := pcall(func() {
32127                 ((*(*(struct {
32128                         Texture
32129                         Anim  TileAnim
32130                         Flags TileFlags
32131
32132                         //mt:if %s.Flags&TileColor != 0
32133                         R, G, B uint8
32134
32135                         //mt:if %s.Flags&TileScale != 0
32136                         Scale uint8
32137
32138                         //mt:if %s.Flags&TileAlign != 0
32139                         Align AlignType
32140                 }))(obj)).Texture).deserialize(r)
32141         }); err != nil {
32142                 if err == io.EOF {
32143                         chk(io.EOF)
32144                 }
32145                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Texture", err))
32146         }
32147         if err := pcall(func() {
32148                 ((*(*(struct {
32149                         Texture
32150                         Anim  TileAnim
32151                         Flags TileFlags
32152
32153                         //mt:if %s.Flags&TileColor != 0
32154                         R, G, B uint8
32155
32156                         //mt:if %s.Flags&TileScale != 0
32157                         Scale uint8
32158
32159                         //mt:if %s.Flags&TileAlign != 0
32160                         Align AlignType
32161                 }))(obj)).Anim).deserialize(r)
32162         }); err != nil {
32163                 if err == io.EOF {
32164                         chk(io.EOF)
32165                 }
32166                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileAnim", err))
32167         }
32168         if err := pcall(func() {
32169                 ((*(*(struct {
32170                         Texture
32171                         Anim  TileAnim
32172                         Flags TileFlags
32173
32174                         //mt:if %s.Flags&TileColor != 0
32175                         R, G, B uint8
32176
32177                         //mt:if %s.Flags&TileScale != 0
32178                         Scale uint8
32179
32180                         //mt:if %s.Flags&TileAlign != 0
32181                         Align AlignType
32182                 }))(obj)).Flags).deserialize(r)
32183         }); err != nil {
32184                 if err == io.EOF {
32185                         chk(io.EOF)
32186                 }
32187                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.TileFlags", err))
32188         }
32189         if (*(*(struct {
32190                 Texture
32191                 Anim  TileAnim
32192                 Flags TileFlags
32193
32194                 //mt:if %s.Flags&TileColor != 0
32195                 R, G, B uint8
32196
32197                 //mt:if %s.Flags&TileScale != 0
32198                 Scale uint8
32199
32200                 //mt:if %s.Flags&TileAlign != 0
32201                 Align AlignType
32202         }))(obj)).Flags&TileColor != 0 {
32203                 {
32204                         p := &(*(*(struct {
32205                                 Texture
32206                                 Anim  TileAnim
32207                                 Flags TileFlags
32208
32209                                 //mt:if %s.Flags&TileColor != 0
32210                                 R, G, B uint8
32211
32212                                 //mt:if %s.Flags&TileScale != 0
32213                                 Scale uint8
32214
32215                                 //mt:if %s.Flags&TileAlign != 0
32216                                 Align AlignType
32217                         }))(obj)).R
32218                         *p = read8(r)
32219                 }
32220                 {
32221                         p := &(*(*(struct {
32222                                 Texture
32223                                 Anim  TileAnim
32224                                 Flags TileFlags
32225
32226                                 //mt:if %s.Flags&TileColor != 0
32227                                 R, G, B uint8
32228
32229                                 //mt:if %s.Flags&TileScale != 0
32230                                 Scale uint8
32231
32232                                 //mt:if %s.Flags&TileAlign != 0
32233                                 Align AlignType
32234                         }))(obj)).G
32235                         *p = read8(r)
32236                 }
32237                 {
32238                         p := &(*(*(struct {
32239                                 Texture
32240                                 Anim  TileAnim
32241                                 Flags TileFlags
32242
32243                                 //mt:if %s.Flags&TileColor != 0
32244                                 R, G, B uint8
32245
32246                                 //mt:if %s.Flags&TileScale != 0
32247                                 Scale uint8
32248
32249                                 //mt:if %s.Flags&TileAlign != 0
32250                                 Align AlignType
32251                         }))(obj)).B
32252                         *p = read8(r)
32253                 }
32254         }
32255         if (*(*(struct {
32256                 Texture
32257                 Anim  TileAnim
32258                 Flags TileFlags
32259
32260                 //mt:if %s.Flags&TileColor != 0
32261                 R, G, B uint8
32262
32263                 //mt:if %s.Flags&TileScale != 0
32264                 Scale uint8
32265
32266                 //mt:if %s.Flags&TileAlign != 0
32267                 Align AlignType
32268         }))(obj)).Flags&TileScale != 0 {
32269                 {
32270                         p := &(*(*(struct {
32271                                 Texture
32272                                 Anim  TileAnim
32273                                 Flags TileFlags
32274
32275                                 //mt:if %s.Flags&TileColor != 0
32276                                 R, G, B uint8
32277
32278                                 //mt:if %s.Flags&TileScale != 0
32279                                 Scale uint8
32280
32281                                 //mt:if %s.Flags&TileAlign != 0
32282                                 Align AlignType
32283                         }))(obj)).Scale
32284                         *p = read8(r)
32285                 }
32286         }
32287         if (*(*(struct {
32288                 Texture
32289                 Anim  TileAnim
32290                 Flags TileFlags
32291
32292                 //mt:if %s.Flags&TileColor != 0
32293                 R, G, B uint8
32294
32295                 //mt:if %s.Flags&TileScale != 0
32296                 Scale uint8
32297
32298                 //mt:if %s.Flags&TileAlign != 0
32299                 Align AlignType
32300         }))(obj)).Flags&TileAlign != 0 {
32301                 if err := pcall(func() {
32302                         ((*(*(struct {
32303                                 Texture
32304                                 Anim  TileAnim
32305                                 Flags TileFlags
32306
32307                                 //mt:if %s.Flags&TileColor != 0
32308                                 R, G, B uint8
32309
32310                                 //mt:if %s.Flags&TileScale != 0
32311                                 Scale uint8
32312
32313                                 //mt:if %s.Flags&TileAlign != 0
32314                                 Align AlignType
32315                         }))(obj)).Align).deserialize(r)
32316                 }); err != nil {
32317                         if err == io.EOF {
32318                                 chk(io.EOF)
32319                         }
32320                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AlignType", err))
32321                 }
32322         }
32323 }
32324
32325 func (obj *WaveType) serialize(w io.Writer) {
32326         {
32327                 x := *(*(uint8))(obj)
32328                 write8(w, uint8(x))
32329         }
32330 }
32331
32332 func (obj *WaveType) deserialize(r io.Reader) {
32333         {
32334                 p := &*(*(uint8))(obj)
32335                 *p = read8(r)
32336         }
32337 }
32338
32339 func (obj *LiquidType) serialize(w io.Writer) {
32340         {
32341                 x := *(*(uint8))(obj)
32342                 write8(w, uint8(x))
32343         }
32344 }
32345
32346 func (obj *LiquidType) deserialize(r io.Reader) {
32347         {
32348                 p := &*(*(uint8))(obj)
32349                 *p = read8(r)
32350         }
32351 }
32352
32353 func (obj *NodeBox) serialize(w io.Writer) {
32354         {
32355                 local375 := uint8(6)
32356                 {
32357                         x := local375
32358                         write8(w, uint8(x))
32359                 }
32360         }
32361         if err := pcall(func() {
32362                 ((*(*(struct {
32363                         Type NodeBoxType
32364
32365                         //mt:if %s.Type == MountedBox
32366                         WallTop, WallBot, WallSides Box
32367
32368                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32369                         Fixed []Box
32370
32371                         //mt:if %s.Type == ConnectedBox
32372                         ConnDirs, DiscoDirs  DirBoxes
32373                         DiscoAll, DiscoSides []Box
32374                 }))(obj)).Type).serialize(w)
32375         }); err != nil {
32376                 if err == io.EOF {
32377                         chk(io.EOF)
32378                 }
32379                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.NodeBoxType", err))
32380         }
32381         if !((*(*(struct {
32382                 Type NodeBoxType
32383
32384                 //mt:if %s.Type == MountedBox
32385                 WallTop, WallBot, WallSides Box
32386
32387                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32388                 Fixed []Box
32389
32390                 //mt:if %s.Type == ConnectedBox
32391                 ConnDirs, DiscoDirs  DirBoxes
32392                 DiscoAll, DiscoSides []Box
32393         }))(obj)).Type < maxBox) {
32394                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32395         }
32396         if (*(*(struct {
32397                 Type NodeBoxType
32398
32399                 //mt:if %s.Type == MountedBox
32400                 WallTop, WallBot, WallSides Box
32401
32402                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32403                 Fixed []Box
32404
32405                 //mt:if %s.Type == ConnectedBox
32406                 ConnDirs, DiscoDirs  DirBoxes
32407                 DiscoAll, DiscoSides []Box
32408         }))(obj)).Type == MountedBox {
32409                 if err := pcall(func() {
32410                         ((*(*(struct {
32411                                 Type NodeBoxType
32412
32413                                 //mt:if %s.Type == MountedBox
32414                                 WallTop, WallBot, WallSides Box
32415
32416                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32417                                 Fixed []Box
32418
32419                                 //mt:if %s.Type == ConnectedBox
32420                                 ConnDirs, DiscoDirs  DirBoxes
32421                                 DiscoAll, DiscoSides []Box
32422                         }))(obj)).WallTop).serialize(w)
32423                 }); err != nil {
32424                         if err == io.EOF {
32425                                 chk(io.EOF)
32426                         }
32427                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32428                 }
32429                 if err := pcall(func() {
32430                         ((*(*(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)).WallBot).serialize(w)
32443                 }); err != nil {
32444                         if err == io.EOF {
32445                                 chk(io.EOF)
32446                         }
32447                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32448                 }
32449                 if err := pcall(func() {
32450                         ((*(*(struct {
32451                                 Type NodeBoxType
32452
32453                                 //mt:if %s.Type == MountedBox
32454                                 WallTop, WallBot, WallSides Box
32455
32456                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32457                                 Fixed []Box
32458
32459                                 //mt:if %s.Type == ConnectedBox
32460                                 ConnDirs, DiscoDirs  DirBoxes
32461                                 DiscoAll, DiscoSides []Box
32462                         }))(obj)).WallSides).serialize(w)
32463                 }); err != nil {
32464                         if err == io.EOF {
32465                                 chk(io.EOF)
32466                         }
32467                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32468                 }
32469         }
32470         if t := (*(*(struct {
32471                 Type NodeBoxType
32472
32473                 //mt:if %s.Type == MountedBox
32474                 WallTop, WallBot, WallSides Box
32475
32476                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32477                 Fixed []Box
32478
32479                 //mt:if %s.Type == ConnectedBox
32480                 ConnDirs, DiscoDirs  DirBoxes
32481                 DiscoAll, DiscoSides []Box
32482         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32483                 if len(((*(*(struct {
32484                         Type NodeBoxType
32485
32486                         //mt:if %s.Type == MountedBox
32487                         WallTop, WallBot, WallSides Box
32488
32489                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32490                         Fixed []Box
32491
32492                         //mt:if %s.Type == ConnectedBox
32493                         ConnDirs, DiscoDirs  DirBoxes
32494                         DiscoAll, DiscoSides []Box
32495                 }))(obj)).Fixed)) > math.MaxUint16 {
32496                         chk(ErrTooLong)
32497                 }
32498                 {
32499                         x := uint16(len(((*(*(struct {
32500                                 Type NodeBoxType
32501
32502                                 //mt:if %s.Type == MountedBox
32503                                 WallTop, WallBot, WallSides Box
32504
32505                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32506                                 Fixed []Box
32507
32508                                 //mt:if %s.Type == ConnectedBox
32509                                 ConnDirs, DiscoDirs  DirBoxes
32510                                 DiscoAll, DiscoSides []Box
32511                         }))(obj)).Fixed)))
32512                         write16(w, uint16(x))
32513                 }
32514                 for local376 := range (*(*(struct {
32515                         Type NodeBoxType
32516
32517                         //mt:if %s.Type == MountedBox
32518                         WallTop, WallBot, WallSides Box
32519
32520                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32521                         Fixed []Box
32522
32523                         //mt:if %s.Type == ConnectedBox
32524                         ConnDirs, DiscoDirs  DirBoxes
32525                         DiscoAll, DiscoSides []Box
32526                 }))(obj)).Fixed {
32527                         if err := pcall(func() {
32528                                 (((*(*(struct {
32529                                         Type NodeBoxType
32530
32531                                         //mt:if %s.Type == MountedBox
32532                                         WallTop, WallBot, WallSides Box
32533
32534                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32535                                         Fixed []Box
32536
32537                                         //mt:if %s.Type == ConnectedBox
32538                                         ConnDirs, DiscoDirs  DirBoxes
32539                                         DiscoAll, DiscoSides []Box
32540                                 }))(obj)).Fixed)[local376]).serialize(w)
32541                         }); err != nil {
32542                                 if err == io.EOF {
32543                                         chk(io.EOF)
32544                                 }
32545                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32546                         }
32547                 }
32548         }
32549         if (*(*(struct {
32550                 Type NodeBoxType
32551
32552                 //mt:if %s.Type == MountedBox
32553                 WallTop, WallBot, WallSides Box
32554
32555                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32556                 Fixed []Box
32557
32558                 //mt:if %s.Type == ConnectedBox
32559                 ConnDirs, DiscoDirs  DirBoxes
32560                 DiscoAll, DiscoSides []Box
32561         }))(obj)).Type == ConnectedBox {
32562                 if err := pcall(func() {
32563                         ((*(*(struct {
32564                                 Type NodeBoxType
32565
32566                                 //mt:if %s.Type == MountedBox
32567                                 WallTop, WallBot, WallSides Box
32568
32569                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32570                                 Fixed []Box
32571
32572                                 //mt:if %s.Type == ConnectedBox
32573                                 ConnDirs, DiscoDirs  DirBoxes
32574                                 DiscoAll, DiscoSides []Box
32575                         }))(obj)).ConnDirs).serialize(w)
32576                 }); err != nil {
32577                         if err == io.EOF {
32578                                 chk(io.EOF)
32579                         }
32580                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32581                 }
32582                 if err := pcall(func() {
32583                         ((*(*(struct {
32584                                 Type NodeBoxType
32585
32586                                 //mt:if %s.Type == MountedBox
32587                                 WallTop, WallBot, WallSides Box
32588
32589                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32590                                 Fixed []Box
32591
32592                                 //mt:if %s.Type == ConnectedBox
32593                                 ConnDirs, DiscoDirs  DirBoxes
32594                                 DiscoAll, DiscoSides []Box
32595                         }))(obj)).DiscoDirs).serialize(w)
32596                 }); err != nil {
32597                         if err == io.EOF {
32598                                 chk(io.EOF)
32599                         }
32600                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32601                 }
32602                 if len(((*(*(struct {
32603                         Type NodeBoxType
32604
32605                         //mt:if %s.Type == MountedBox
32606                         WallTop, WallBot, WallSides Box
32607
32608                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32609                         Fixed []Box
32610
32611                         //mt:if %s.Type == ConnectedBox
32612                         ConnDirs, DiscoDirs  DirBoxes
32613                         DiscoAll, DiscoSides []Box
32614                 }))(obj)).DiscoAll)) > math.MaxUint16 {
32615                         chk(ErrTooLong)
32616                 }
32617                 {
32618                         x := uint16(len(((*(*(struct {
32619                                 Type NodeBoxType
32620
32621                                 //mt:if %s.Type == MountedBox
32622                                 WallTop, WallBot, WallSides Box
32623
32624                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32625                                 Fixed []Box
32626
32627                                 //mt:if %s.Type == ConnectedBox
32628                                 ConnDirs, DiscoDirs  DirBoxes
32629                                 DiscoAll, DiscoSides []Box
32630                         }))(obj)).DiscoAll)))
32631                         write16(w, uint16(x))
32632                 }
32633                 for local377 := range (*(*(struct {
32634                         Type NodeBoxType
32635
32636                         //mt:if %s.Type == MountedBox
32637                         WallTop, WallBot, WallSides Box
32638
32639                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32640                         Fixed []Box
32641
32642                         //mt:if %s.Type == ConnectedBox
32643                         ConnDirs, DiscoDirs  DirBoxes
32644                         DiscoAll, DiscoSides []Box
32645                 }))(obj)).DiscoAll {
32646                         if err := pcall(func() {
32647                                 (((*(*(struct {
32648                                         Type NodeBoxType
32649
32650                                         //mt:if %s.Type == MountedBox
32651                                         WallTop, WallBot, WallSides Box
32652
32653                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32654                                         Fixed []Box
32655
32656                                         //mt:if %s.Type == ConnectedBox
32657                                         ConnDirs, DiscoDirs  DirBoxes
32658                                         DiscoAll, DiscoSides []Box
32659                                 }))(obj)).DiscoAll)[local377]).serialize(w)
32660                         }); err != nil {
32661                                 if err == io.EOF {
32662                                         chk(io.EOF)
32663                                 }
32664                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32665                         }
32666                 }
32667                 if len(((*(*(struct {
32668                         Type NodeBoxType
32669
32670                         //mt:if %s.Type == MountedBox
32671                         WallTop, WallBot, WallSides Box
32672
32673                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32674                         Fixed []Box
32675
32676                         //mt:if %s.Type == ConnectedBox
32677                         ConnDirs, DiscoDirs  DirBoxes
32678                         DiscoAll, DiscoSides []Box
32679                 }))(obj)).DiscoSides)) > math.MaxUint16 {
32680                         chk(ErrTooLong)
32681                 }
32682                 {
32683                         x := uint16(len(((*(*(struct {
32684                                 Type NodeBoxType
32685
32686                                 //mt:if %s.Type == MountedBox
32687                                 WallTop, WallBot, WallSides Box
32688
32689                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32690                                 Fixed []Box
32691
32692                                 //mt:if %s.Type == ConnectedBox
32693                                 ConnDirs, DiscoDirs  DirBoxes
32694                                 DiscoAll, DiscoSides []Box
32695                         }))(obj)).DiscoSides)))
32696                         write16(w, uint16(x))
32697                 }
32698                 for local378 := range (*(*(struct {
32699                         Type NodeBoxType
32700
32701                         //mt:if %s.Type == MountedBox
32702                         WallTop, WallBot, WallSides Box
32703
32704                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32705                         Fixed []Box
32706
32707                         //mt:if %s.Type == ConnectedBox
32708                         ConnDirs, DiscoDirs  DirBoxes
32709                         DiscoAll, DiscoSides []Box
32710                 }))(obj)).DiscoSides {
32711                         if err := pcall(func() {
32712                                 (((*(*(struct {
32713                                         Type NodeBoxType
32714
32715                                         //mt:if %s.Type == MountedBox
32716                                         WallTop, WallBot, WallSides Box
32717
32718                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32719                                         Fixed []Box
32720
32721                                         //mt:if %s.Type == ConnectedBox
32722                                         ConnDirs, DiscoDirs  DirBoxes
32723                                         DiscoAll, DiscoSides []Box
32724                                 }))(obj)).DiscoSides)[local378]).serialize(w)
32725                         }); err != nil {
32726                                 if err == io.EOF {
32727                                         chk(io.EOF)
32728                                 }
32729                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32730                         }
32731                 }
32732         }
32733 }
32734
32735 func (obj *NodeBox) deserialize(r io.Reader) {
32736         {
32737                 var local379 uint8
32738                 local380 := uint8(6)
32739                 {
32740                         p := &local379
32741                         *p = read8(r)
32742                 }
32743                 if local379 != local380 {
32744                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local379))
32745                 }
32746         }
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)).Type).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.NodeBoxType", err))
32766         }
32767         if !((*(*(struct {
32768                 Type NodeBoxType
32769
32770                 //mt:if %s.Type == MountedBox
32771                 WallTop, WallBot, WallSides Box
32772
32773                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32774                 Fixed []Box
32775
32776                 //mt:if %s.Type == ConnectedBox
32777                 ConnDirs, DiscoDirs  DirBoxes
32778                 DiscoAll, DiscoSides []Box
32779         }))(obj)).Type < maxBox) {
32780                 chk(errors.New("assertion failed: %s.Type < maxBox"))
32781         }
32782         if (*(*(struct {
32783                 Type NodeBoxType
32784
32785                 //mt:if %s.Type == MountedBox
32786                 WallTop, WallBot, WallSides Box
32787
32788                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32789                 Fixed []Box
32790
32791                 //mt:if %s.Type == ConnectedBox
32792                 ConnDirs, DiscoDirs  DirBoxes
32793                 DiscoAll, DiscoSides []Box
32794         }))(obj)).Type == MountedBox {
32795                 if err := pcall(func() {
32796                         ((*(*(struct {
32797                                 Type NodeBoxType
32798
32799                                 //mt:if %s.Type == MountedBox
32800                                 WallTop, WallBot, WallSides Box
32801
32802                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32803                                 Fixed []Box
32804
32805                                 //mt:if %s.Type == ConnectedBox
32806                                 ConnDirs, DiscoDirs  DirBoxes
32807                                 DiscoAll, DiscoSides []Box
32808                         }))(obj)).WallTop).deserialize(r)
32809                 }); err != nil {
32810                         if err == io.EOF {
32811                                 chk(io.EOF)
32812                         }
32813                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32814                 }
32815                 if err := pcall(func() {
32816                         ((*(*(struct {
32817                                 Type NodeBoxType
32818
32819                                 //mt:if %s.Type == MountedBox
32820                                 WallTop, WallBot, WallSides Box
32821
32822                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32823                                 Fixed []Box
32824
32825                                 //mt:if %s.Type == ConnectedBox
32826                                 ConnDirs, DiscoDirs  DirBoxes
32827                                 DiscoAll, DiscoSides []Box
32828                         }))(obj)).WallBot).deserialize(r)
32829                 }); err != nil {
32830                         if err == io.EOF {
32831                                 chk(io.EOF)
32832                         }
32833                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32834                 }
32835                 if err := pcall(func() {
32836                         ((*(*(struct {
32837                                 Type NodeBoxType
32838
32839                                 //mt:if %s.Type == MountedBox
32840                                 WallTop, WallBot, WallSides Box
32841
32842                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32843                                 Fixed []Box
32844
32845                                 //mt:if %s.Type == ConnectedBox
32846                                 ConnDirs, DiscoDirs  DirBoxes
32847                                 DiscoAll, DiscoSides []Box
32848                         }))(obj)).WallSides).deserialize(r)
32849                 }); err != nil {
32850                         if err == io.EOF {
32851                                 chk(io.EOF)
32852                         }
32853                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32854                 }
32855         }
32856         if t := (*(*(struct {
32857                 Type NodeBoxType
32858
32859                 //mt:if %s.Type == MountedBox
32860                 WallTop, WallBot, WallSides Box
32861
32862                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32863                 Fixed []Box
32864
32865                 //mt:if %s.Type == ConnectedBox
32866                 ConnDirs, DiscoDirs  DirBoxes
32867                 DiscoAll, DiscoSides []Box
32868         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
32869                 var local381 uint16
32870                 {
32871                         p := &local381
32872                         *p = read16(r)
32873                 }
32874                 ((*(*(struct {
32875                         Type NodeBoxType
32876
32877                         //mt:if %s.Type == MountedBox
32878                         WallTop, WallBot, WallSides Box
32879
32880                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32881                         Fixed []Box
32882
32883                         //mt:if %s.Type == ConnectedBox
32884                         ConnDirs, DiscoDirs  DirBoxes
32885                         DiscoAll, DiscoSides []Box
32886                 }))(obj)).Fixed) = make([]Box, local381)
32887                 for local382 := range (*(*(struct {
32888                         Type NodeBoxType
32889
32890                         //mt:if %s.Type == MountedBox
32891                         WallTop, WallBot, WallSides Box
32892
32893                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32894                         Fixed []Box
32895
32896                         //mt:if %s.Type == ConnectedBox
32897                         ConnDirs, DiscoDirs  DirBoxes
32898                         DiscoAll, DiscoSides []Box
32899                 }))(obj)).Fixed {
32900                         if err := pcall(func() {
32901                                 (((*(*(struct {
32902                                         Type NodeBoxType
32903
32904                                         //mt:if %s.Type == MountedBox
32905                                         WallTop, WallBot, WallSides Box
32906
32907                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32908                                         Fixed []Box
32909
32910                                         //mt:if %s.Type == ConnectedBox
32911                                         ConnDirs, DiscoDirs  DirBoxes
32912                                         DiscoAll, DiscoSides []Box
32913                                 }))(obj)).Fixed)[local382]).deserialize(r)
32914                         }); err != nil {
32915                                 if err == io.EOF {
32916                                         chk(io.EOF)
32917                                 }
32918                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
32919                         }
32920                 }
32921         }
32922         if (*(*(struct {
32923                 Type NodeBoxType
32924
32925                 //mt:if %s.Type == MountedBox
32926                 WallTop, WallBot, WallSides Box
32927
32928                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32929                 Fixed []Box
32930
32931                 //mt:if %s.Type == ConnectedBox
32932                 ConnDirs, DiscoDirs  DirBoxes
32933                 DiscoAll, DiscoSides []Box
32934         }))(obj)).Type == ConnectedBox {
32935                 if err := pcall(func() {
32936                         ((*(*(struct {
32937                                 Type NodeBoxType
32938
32939                                 //mt:if %s.Type == MountedBox
32940                                 WallTop, WallBot, WallSides Box
32941
32942                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32943                                 Fixed []Box
32944
32945                                 //mt:if %s.Type == ConnectedBox
32946                                 ConnDirs, DiscoDirs  DirBoxes
32947                                 DiscoAll, DiscoSides []Box
32948                         }))(obj)).ConnDirs).deserialize(r)
32949                 }); err != nil {
32950                         if err == io.EOF {
32951                                 chk(io.EOF)
32952                         }
32953                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32954                 }
32955                 if err := pcall(func() {
32956                         ((*(*(struct {
32957                                 Type NodeBoxType
32958
32959                                 //mt:if %s.Type == MountedBox
32960                                 WallTop, WallBot, WallSides Box
32961
32962                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32963                                 Fixed []Box
32964
32965                                 //mt:if %s.Type == ConnectedBox
32966                                 ConnDirs, DiscoDirs  DirBoxes
32967                                 DiscoAll, DiscoSides []Box
32968                         }))(obj)).DiscoDirs).deserialize(r)
32969                 }); err != nil {
32970                         if err == io.EOF {
32971                                 chk(io.EOF)
32972                         }
32973                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DirBoxes", err))
32974                 }
32975                 var local383 uint16
32976                 {
32977                         p := &local383
32978                         *p = read16(r)
32979                 }
32980                 ((*(*(struct {
32981                         Type NodeBoxType
32982
32983                         //mt:if %s.Type == MountedBox
32984                         WallTop, WallBot, WallSides Box
32985
32986                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
32987                         Fixed []Box
32988
32989                         //mt:if %s.Type == ConnectedBox
32990                         ConnDirs, DiscoDirs  DirBoxes
32991                         DiscoAll, DiscoSides []Box
32992                 }))(obj)).DiscoAll) = make([]Box, local383)
32993                 for local384 := range (*(*(struct {
32994                         Type NodeBoxType
32995
32996                         //mt:if %s.Type == MountedBox
32997                         WallTop, WallBot, WallSides Box
32998
32999                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33000                         Fixed []Box
33001
33002                         //mt:if %s.Type == ConnectedBox
33003                         ConnDirs, DiscoDirs  DirBoxes
33004                         DiscoAll, DiscoSides []Box
33005                 }))(obj)).DiscoAll {
33006                         if err := pcall(func() {
33007                                 (((*(*(struct {
33008                                         Type NodeBoxType
33009
33010                                         //mt:if %s.Type == MountedBox
33011                                         WallTop, WallBot, WallSides Box
33012
33013                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33014                                         Fixed []Box
33015
33016                                         //mt:if %s.Type == ConnectedBox
33017                                         ConnDirs, DiscoDirs  DirBoxes
33018                                         DiscoAll, DiscoSides []Box
33019                                 }))(obj)).DiscoAll)[local384]).deserialize(r)
33020                         }); err != nil {
33021                                 if err == io.EOF {
33022                                         chk(io.EOF)
33023                                 }
33024                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
33025                         }
33026                 }
33027                 var local385 uint16
33028                 {
33029                         p := &local385
33030                         *p = read16(r)
33031                 }
33032                 ((*(*(struct {
33033                         Type NodeBoxType
33034
33035                         //mt:if %s.Type == MountedBox
33036                         WallTop, WallBot, WallSides Box
33037
33038                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33039                         Fixed []Box
33040
33041                         //mt:if %s.Type == ConnectedBox
33042                         ConnDirs, DiscoDirs  DirBoxes
33043                         DiscoAll, DiscoSides []Box
33044                 }))(obj)).DiscoSides) = make([]Box, local385)
33045                 for local386 := range (*(*(struct {
33046                         Type NodeBoxType
33047
33048                         //mt:if %s.Type == MountedBox
33049                         WallTop, WallBot, WallSides Box
33050
33051                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33052                         Fixed []Box
33053
33054                         //mt:if %s.Type == ConnectedBox
33055                         ConnDirs, DiscoDirs  DirBoxes
33056                         DiscoAll, DiscoSides []Box
33057                 }))(obj)).DiscoSides {
33058                         if err := pcall(func() {
33059                                 (((*(*(struct {
33060                                         Type NodeBoxType
33061
33062                                         //mt:if %s.Type == MountedBox
33063                                         WallTop, WallBot, WallSides Box
33064
33065                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33066                                         Fixed []Box
33067
33068                                         //mt:if %s.Type == ConnectedBox
33069                                         ConnDirs, DiscoDirs  DirBoxes
33070                                         DiscoAll, DiscoSides []Box
33071                                 }))(obj)).DiscoSides)[local386]).deserialize(r)
33072                         }); err != nil {
33073                                 if err == io.EOF {
33074                                         chk(io.EOF)
33075                                 }
33076                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
33077                         }
33078                 }
33079         }
33080 }
33081
33082 func (obj *SoundDef) serialize(w io.Writer) {
33083         if len(([]byte((*(*(struct {
33084                 Name              string
33085                 Gain, Pitch, Fade float32
33086         }))(obj)).Name))) > math.MaxUint16 {
33087                 chk(ErrTooLong)
33088         }
33089         {
33090                 x := uint16(len(([]byte((*(*(struct {
33091                         Name              string
33092                         Gain, Pitch, Fade float32
33093                 }))(obj)).Name))))
33094                 write16(w, uint16(x))
33095         }
33096         {
33097                 _, err := w.Write(([]byte((*(*(struct {
33098                         Name              string
33099                         Gain, Pitch, Fade float32
33100                 }))(obj)).Name))[:])
33101                 chk(err)
33102         }
33103         {
33104                 x := (*(*(struct {
33105                         Name              string
33106                         Gain, Pitch, Fade float32
33107                 }))(obj)).Gain
33108                 write32(w, math.Float32bits(x))
33109         }
33110         {
33111                 x := (*(*(struct {
33112                         Name              string
33113                         Gain, Pitch, Fade float32
33114                 }))(obj)).Pitch
33115                 write32(w, math.Float32bits(x))
33116         }
33117         {
33118                 x := (*(*(struct {
33119                         Name              string
33120                         Gain, Pitch, Fade float32
33121                 }))(obj)).Fade
33122                 write32(w, math.Float32bits(x))
33123         }
33124 }
33125
33126 func (obj *SoundDef) deserialize(r io.Reader) {
33127         var local387 []uint8
33128         var local388 uint16
33129         {
33130                 p := &local388
33131                 *p = read16(r)
33132         }
33133         (local387) = make([]uint8, local388)
33134         {
33135                 _, err := io.ReadFull(r, (local387)[:])
33136                 chk(err)
33137         }
33138         ((*(*(struct {
33139                 Name              string
33140                 Gain, Pitch, Fade float32
33141         }))(obj)).Name) = string(local387)
33142         {
33143                 p := &(*(*(struct {
33144                         Name              string
33145                         Gain, Pitch, Fade float32
33146                 }))(obj)).Gain
33147                 *p = math.Float32frombits(read32(r))
33148         }
33149         {
33150                 p := &(*(*(struct {
33151                         Name              string
33152                         Gain, Pitch, Fade float32
33153                 }))(obj)).Pitch
33154                 *p = math.Float32frombits(read32(r))
33155         }
33156         {
33157                 p := &(*(*(struct {
33158                         Name              string
33159                         Gain, Pitch, Fade float32
33160                 }))(obj)).Fade
33161                 *p = math.Float32frombits(read32(r))
33162         }
33163 }
33164
33165 func (obj *AlphaUse) serialize(w io.Writer) {
33166         {
33167                 x := *(*(uint8))(obj)
33168                 write8(w, uint8(x))
33169         }
33170 }
33171
33172 func (obj *AlphaUse) deserialize(r io.Reader) {
33173         {
33174                 p := &*(*(uint8))(obj)
33175                 *p = read8(r)
33176         }
33177 }
33178
33179 func (obj *Keys) serialize(w io.Writer) {
33180         {
33181                 x := *(*(uint32))(obj)
33182                 write32(w, uint32(x))
33183         }
33184 }
33185
33186 func (obj *Keys) deserialize(r io.Reader) {
33187         {
33188                 p := &*(*(uint32))(obj)
33189                 *p = read32(r)
33190         }
33191 }
33192
33193 func (obj *MapBlkFlags) serialize(w io.Writer) {
33194         {
33195                 x := *(*(uint8))(obj)
33196                 write8(w, uint8(x))
33197         }
33198 }
33199
33200 func (obj *MapBlkFlags) deserialize(r io.Reader) {
33201         {
33202                 p := &*(*(uint8))(obj)
33203                 *p = read8(r)
33204         }
33205 }
33206
33207 func (obj *LitFromBlks) serialize(w io.Writer) {
33208         {
33209                 x := *(*(uint16))(obj)
33210                 write16(w, uint16(x))
33211         }
33212 }
33213
33214 func (obj *LitFromBlks) deserialize(r io.Reader) {
33215         {
33216                 p := &*(*(uint16))(obj)
33217                 *p = read16(r)
33218         }
33219 }
33220
33221 func (obj *AOInitData) serialize(w io.Writer) {
33222         {
33223                 local389 := uint8(1)
33224                 {
33225                         x := local389
33226                         write8(w, uint8(x))
33227                 }
33228         }
33229         if len(([]byte((*(*(struct {
33230
33231                 // For players.
33232                 Name     string
33233                 IsPlayer bool
33234
33235                 ID AOID
33236
33237                 Pos
33238                 Rot [3]float32
33239
33240                 HP uint16
33241
33242                 // See (de)serialize.fmt.
33243                 Msgs []AOMsg
33244         }))(obj)).Name))) > math.MaxUint16 {
33245                 chk(ErrTooLong)
33246         }
33247         {
33248                 x := uint16(len(([]byte((*(*(struct {
33249
33250                         // For players.
33251                         Name     string
33252                         IsPlayer bool
33253
33254                         ID AOID
33255
33256                         Pos
33257                         Rot [3]float32
33258
33259                         HP uint16
33260
33261                         // See (de)serialize.fmt.
33262                         Msgs []AOMsg
33263                 }))(obj)).Name))))
33264                 write16(w, uint16(x))
33265         }
33266         {
33267                 _, err := w.Write(([]byte((*(*(struct {
33268
33269                         // For players.
33270                         Name     string
33271                         IsPlayer bool
33272
33273                         ID AOID
33274
33275                         Pos
33276                         Rot [3]float32
33277
33278                         HP uint16
33279
33280                         // See (de)serialize.fmt.
33281                         Msgs []AOMsg
33282                 }))(obj)).Name))[:])
33283                 chk(err)
33284         }
33285         {
33286                 x := (*(*(struct {
33287
33288                         // For players.
33289                         Name     string
33290                         IsPlayer bool
33291
33292                         ID AOID
33293
33294                         Pos
33295                         Rot [3]float32
33296
33297                         HP uint16
33298
33299                         // See (de)serialize.fmt.
33300                         Msgs []AOMsg
33301                 }))(obj)).IsPlayer
33302                 if x {
33303                         write8(w, 1)
33304                 } else {
33305                         write8(w, 0)
33306                 }
33307
33308         }
33309         if err := pcall(func() {
33310                 ((*(*(struct {
33311
33312                         // For players.
33313                         Name     string
33314                         IsPlayer bool
33315
33316                         ID AOID
33317
33318                         Pos
33319                         Rot [3]float32
33320
33321                         HP uint16
33322
33323                         // See (de)serialize.fmt.
33324                         Msgs []AOMsg
33325                 }))(obj)).ID).serialize(w)
33326         }); err != nil {
33327                 if err == io.EOF {
33328                         chk(io.EOF)
33329                 }
33330                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
33331         }
33332         if err := pcall(func() {
33333                 ((*(*(struct {
33334
33335                         // For players.
33336                         Name     string
33337                         IsPlayer bool
33338
33339                         ID AOID
33340
33341                         Pos
33342                         Rot [3]float32
33343
33344                         HP uint16
33345
33346                         // See (de)serialize.fmt.
33347                         Msgs []AOMsg
33348                 }))(obj)).Pos).serialize(w)
33349         }); err != nil {
33350                 if err == io.EOF {
33351                         chk(io.EOF)
33352                 }
33353                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
33354         }
33355         for local390 := range (*(*(struct {
33356
33357                 // For players.
33358                 Name     string
33359                 IsPlayer bool
33360
33361                 ID AOID
33362
33363                 Pos
33364                 Rot [3]float32
33365
33366                 HP uint16
33367
33368                 // See (de)serialize.fmt.
33369                 Msgs []AOMsg
33370         }))(obj)).Rot {
33371                 {
33372                         x := ((*(*(struct {
33373
33374                                 // For players.
33375                                 Name     string
33376                                 IsPlayer bool
33377
33378                                 ID AOID
33379
33380                                 Pos
33381                                 Rot [3]float32
33382
33383                                 HP uint16
33384
33385                                 // See (de)serialize.fmt.
33386                                 Msgs []AOMsg
33387                         }))(obj)).Rot)[local390]
33388                         write32(w, math.Float32bits(x))
33389                 }
33390         }
33391         {
33392                 x := (*(*(struct {
33393
33394                         // For players.
33395                         Name     string
33396                         IsPlayer bool
33397
33398                         ID AOID
33399
33400                         Pos
33401                         Rot [3]float32
33402
33403                         HP uint16
33404
33405                         // See (de)serialize.fmt.
33406                         Msgs []AOMsg
33407                 }))(obj)).HP
33408                 write16(w, uint16(x))
33409         }
33410         {
33411                 x := (*(*(struct {
33412
33413                         // For players.
33414                         Name     string
33415                         IsPlayer bool
33416
33417                         ID AOID
33418
33419                         Pos
33420                         Rot [3]float32
33421
33422                         HP uint16
33423
33424                         // See (de)serialize.fmt.
33425                         Msgs []AOMsg
33426                 }))(obj)).Msgs
33427                 { // For AOInitData.Msgs.
33428                         if len(x) > math.MaxUint8 {
33429                                 chk(ErrTooLong)
33430                         }
33431                         write8(w, uint8(len(x)))
33432                         for _, msg := range x {
33433                                 var b bytes.Buffer
33434                                 chk(writeAOMsg(&b, msg))
33435                                 if b.Len() > math.MaxUint32 {
33436                                         chk(ErrTooLong)
33437                                 }
33438                                 write32(w, uint32(b.Len()))
33439                                 _, err := b.WriteTo(w)
33440                                 chk(err)
33441                         }
33442                 }
33443
33444         }
33445 }
33446
33447 func (obj *AOInitData) deserialize(r io.Reader) {
33448         {
33449                 var local391 uint8
33450                 local392 := uint8(1)
33451                 {
33452                         p := &local391
33453                         *p = read8(r)
33454                 }
33455                 if local391 != local392 {
33456                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local391))
33457                 }
33458         }
33459         var local393 []uint8
33460         var local394 uint16
33461         {
33462                 p := &local394
33463                 *p = read16(r)
33464         }
33465         (local393) = make([]uint8, local394)
33466         {
33467                 _, err := io.ReadFull(r, (local393)[:])
33468                 chk(err)
33469         }
33470         ((*(*(struct {
33471
33472                 // For players.
33473                 Name     string
33474                 IsPlayer bool
33475
33476                 ID AOID
33477
33478                 Pos
33479                 Rot [3]float32
33480
33481                 HP uint16
33482
33483                 // See (de)serialize.fmt.
33484                 Msgs []AOMsg
33485         }))(obj)).Name) = string(local393)
33486         {
33487                 p := &(*(*(struct {
33488
33489                         // For players.
33490                         Name     string
33491                         IsPlayer bool
33492
33493                         ID AOID
33494
33495                         Pos
33496                         Rot [3]float32
33497
33498                         HP uint16
33499
33500                         // See (de)serialize.fmt.
33501                         Msgs []AOMsg
33502                 }))(obj)).IsPlayer
33503                 switch n := read8(r); n {
33504                 case 0:
33505                         *p = false
33506                 case 1:
33507                         *p = true
33508                 default:
33509                         chk(fmt.Errorf("invalid bool: %d", n))
33510                 }
33511
33512         }
33513         if err := pcall(func() {
33514                 ((*(*(struct {
33515
33516                         // For players.
33517                         Name     string
33518                         IsPlayer bool
33519
33520                         ID AOID
33521
33522                         Pos
33523                         Rot [3]float32
33524
33525                         HP uint16
33526
33527                         // See (de)serialize.fmt.
33528                         Msgs []AOMsg
33529                 }))(obj)).ID).deserialize(r)
33530         }); err != nil {
33531                 if err == io.EOF {
33532                         chk(io.EOF)
33533                 }
33534                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.AOID", err))
33535         }
33536         if err := pcall(func() {
33537                 ((*(*(struct {
33538
33539                         // For players.
33540                         Name     string
33541                         IsPlayer bool
33542
33543                         ID AOID
33544
33545                         Pos
33546                         Rot [3]float32
33547
33548                         HP uint16
33549
33550                         // See (de)serialize.fmt.
33551                         Msgs []AOMsg
33552                 }))(obj)).Pos).deserialize(r)
33553         }); err != nil {
33554                 if err == io.EOF {
33555                         chk(io.EOF)
33556                 }
33557                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Pos", err))
33558         }
33559         for local395 := range (*(*(struct {
33560
33561                 // For players.
33562                 Name     string
33563                 IsPlayer bool
33564
33565                 ID AOID
33566
33567                 Pos
33568                 Rot [3]float32
33569
33570                 HP uint16
33571
33572                 // See (de)serialize.fmt.
33573                 Msgs []AOMsg
33574         }))(obj)).Rot {
33575                 {
33576                         p := &((*(*(struct {
33577
33578                                 // For players.
33579                                 Name     string
33580                                 IsPlayer bool
33581
33582                                 ID AOID
33583
33584                                 Pos
33585                                 Rot [3]float32
33586
33587                                 HP uint16
33588
33589                                 // See (de)serialize.fmt.
33590                                 Msgs []AOMsg
33591                         }))(obj)).Rot)[local395]
33592                         *p = math.Float32frombits(read32(r))
33593                 }
33594         }
33595         {
33596                 p := &(*(*(struct {
33597
33598                         // For players.
33599                         Name     string
33600                         IsPlayer bool
33601
33602                         ID AOID
33603
33604                         Pos
33605                         Rot [3]float32
33606
33607                         HP uint16
33608
33609                         // See (de)serialize.fmt.
33610                         Msgs []AOMsg
33611                 }))(obj)).HP
33612                 *p = read16(r)
33613         }
33614         {
33615                 p := &(*(*(struct {
33616
33617                         // For players.
33618                         Name     string
33619                         IsPlayer bool
33620
33621                         ID AOID
33622
33623                         Pos
33624                         Rot [3]float32
33625
33626                         HP uint16
33627
33628                         // See (de)serialize.fmt.
33629                         Msgs []AOMsg
33630                 }))(obj)).Msgs
33631                 { // For AOInitData.Msgs.
33632                         *p = make([]AOMsg, read8(r))
33633                         for i := range *p {
33634                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
33635                                 msg, err := readAOMsg(r)
33636                                 chk(err)
33637                                 (*p)[i] = msg
33638                                 if r.N > 0 {
33639                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
33640                                 }
33641                         }
33642                 }
33643
33644         }
33645 }
33646
33647 func (obj *ItemType) serialize(w io.Writer) {
33648         {
33649                 x := *(*(uint8))(obj)
33650                 write8(w, uint8(x))
33651         }
33652 }
33653
33654 func (obj *ItemType) deserialize(r io.Reader) {
33655         {
33656                 p := &*(*(uint8))(obj)
33657                 *p = read8(r)
33658         }
33659 }
33660
33661 func (obj *ToolCaps) serialize(w io.Writer) {
33662         if _ = (*(*(struct {
33663                 //mt:if _ = %s; false
33664                 NonNil bool
33665
33666                 AttackCooldown float32
33667                 MaxDropLvl     int16
33668
33669                 //mt:len32
33670                 GroupCaps []ToolGroupCap
33671
33672                 //mt:len32
33673                 DmgGroups []Group
33674
33675                 //mt:32tou16
33676                 PunchUses int32
33677         }))(obj)); false {
33678                 {
33679                         x := (*(*(struct {
33680                                 //mt:if _ = %s; false
33681                                 NonNil bool
33682
33683                                 AttackCooldown float32
33684                                 MaxDropLvl     int16
33685
33686                                 //mt:len32
33687                                 GroupCaps []ToolGroupCap
33688
33689                                 //mt:len32
33690                                 DmgGroups []Group
33691
33692                                 //mt:32tou16
33693                                 PunchUses int32
33694                         }))(obj)).NonNil
33695                         if x {
33696                                 write8(w, 1)
33697                         } else {
33698                                 write8(w, 0)
33699                         }
33700
33701                 }
33702         }
33703         {
33704                 ow := w
33705                 w := new(bytes.Buffer)
33706                 /*
33707                    if r.N > 0 { (*(*(struct {
33708                         //mt:if _ = %s; false
33709                         NonNil  bool
33710
33711                         AttackCooldown  float32
33712                         MaxDropLvl      int16
33713
33714                         //mt:len32
33715                         GroupCaps       []ToolGroupCap
33716
33717                         //mt:len32
33718                         DmgGroups       []Group
33719
33720                         //mt:32tou16
33721                         PunchUses       int32
33722                    }))(obj)).NonNil = true}; /**/{
33723                         if (*(*(struct {
33724                                 //mt:if _ = %s; false
33725                                 NonNil bool
33726
33727                                 AttackCooldown float32
33728                                 MaxDropLvl     int16
33729
33730                                 //mt:len32
33731                                 GroupCaps []ToolGroupCap
33732
33733                                 //mt:len32
33734                                 DmgGroups []Group
33735
33736                                 //mt:32tou16
33737                                 PunchUses int32
33738                         }))(obj)).NonNil {
33739                                 {
33740                                         local396 := uint8(5)
33741                                         {
33742                                                 x := local396
33743                                                 write8(w, uint8(x))
33744                                         }
33745                                 }
33746                                 {
33747                                         x := (*(*(struct {
33748                                                 //mt:if _ = %s; false
33749                                                 NonNil bool
33750
33751                                                 AttackCooldown float32
33752                                                 MaxDropLvl     int16
33753
33754                                                 //mt:len32
33755                                                 GroupCaps []ToolGroupCap
33756
33757                                                 //mt:len32
33758                                                 DmgGroups []Group
33759
33760                                                 //mt:32tou16
33761                                                 PunchUses int32
33762                                         }))(obj)).AttackCooldown
33763                                         write32(w, math.Float32bits(x))
33764                                 }
33765                                 {
33766                                         x := (*(*(struct {
33767                                                 //mt:if _ = %s; false
33768                                                 NonNil bool
33769
33770                                                 AttackCooldown float32
33771                                                 MaxDropLvl     int16
33772
33773                                                 //mt:len32
33774                                                 GroupCaps []ToolGroupCap
33775
33776                                                 //mt:len32
33777                                                 DmgGroups []Group
33778
33779                                                 //mt:32tou16
33780                                                 PunchUses int32
33781                                         }))(obj)).MaxDropLvl
33782                                         write16(w, uint16(x))
33783                                 }
33784                                 if len(((*(*(struct {
33785                                         //mt:if _ = %s; false
33786                                         NonNil bool
33787
33788                                         AttackCooldown float32
33789                                         MaxDropLvl     int16
33790
33791                                         //mt:len32
33792                                         GroupCaps []ToolGroupCap
33793
33794                                         //mt:len32
33795                                         DmgGroups []Group
33796
33797                                         //mt:32tou16
33798                                         PunchUses int32
33799                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
33800                                         chk(ErrTooLong)
33801                                 }
33802                                 {
33803                                         x := uint32(len(((*(*(struct {
33804                                                 //mt:if _ = %s; false
33805                                                 NonNil bool
33806
33807                                                 AttackCooldown float32
33808                                                 MaxDropLvl     int16
33809
33810                                                 //mt:len32
33811                                                 GroupCaps []ToolGroupCap
33812
33813                                                 //mt:len32
33814                                                 DmgGroups []Group
33815
33816                                                 //mt:32tou16
33817                                                 PunchUses int32
33818                                         }))(obj)).GroupCaps)))
33819                                         write32(w, uint32(x))
33820                                 }
33821                                 for local397 := range (*(*(struct {
33822                                         //mt:if _ = %s; false
33823                                         NonNil bool
33824
33825                                         AttackCooldown float32
33826                                         MaxDropLvl     int16
33827
33828                                         //mt:len32
33829                                         GroupCaps []ToolGroupCap
33830
33831                                         //mt:len32
33832                                         DmgGroups []Group
33833
33834                                         //mt:32tou16
33835                                         PunchUses int32
33836                                 }))(obj)).GroupCaps {
33837                                         if err := pcall(func() {
33838                                                 (((*(*(struct {
33839                                                         //mt:if _ = %s; false
33840                                                         NonNil bool
33841
33842                                                         AttackCooldown float32
33843                                                         MaxDropLvl     int16
33844
33845                                                         //mt:len32
33846                                                         GroupCaps []ToolGroupCap
33847
33848                                                         //mt:len32
33849                                                         DmgGroups []Group
33850
33851                                                         //mt:32tou16
33852                                                         PunchUses int32
33853                                                 }))(obj)).GroupCaps)[local397]).serialize(w)
33854                                         }); err != nil {
33855                                                 if err == io.EOF {
33856                                                         chk(io.EOF)
33857                                                 }
33858                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolGroupCap", err))
33859                                         }
33860                                 }
33861                                 if len(((*(*(struct {
33862                                         //mt:if _ = %s; false
33863                                         NonNil bool
33864
33865                                         AttackCooldown float32
33866                                         MaxDropLvl     int16
33867
33868                                         //mt:len32
33869                                         GroupCaps []ToolGroupCap
33870
33871                                         //mt:len32
33872                                         DmgGroups []Group
33873
33874                                         //mt:32tou16
33875                                         PunchUses int32
33876                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
33877                                         chk(ErrTooLong)
33878                                 }
33879                                 {
33880                                         x := uint32(len(((*(*(struct {
33881                                                 //mt:if _ = %s; false
33882                                                 NonNil bool
33883
33884                                                 AttackCooldown float32
33885                                                 MaxDropLvl     int16
33886
33887                                                 //mt:len32
33888                                                 GroupCaps []ToolGroupCap
33889
33890                                                 //mt:len32
33891                                                 DmgGroups []Group
33892
33893                                                 //mt:32tou16
33894                                                 PunchUses int32
33895                                         }))(obj)).DmgGroups)))
33896                                         write32(w, uint32(x))
33897                                 }
33898                                 for local398 := range (*(*(struct {
33899                                         //mt:if _ = %s; false
33900                                         NonNil bool
33901
33902                                         AttackCooldown float32
33903                                         MaxDropLvl     int16
33904
33905                                         //mt:len32
33906                                         GroupCaps []ToolGroupCap
33907
33908                                         //mt:len32
33909                                         DmgGroups []Group
33910
33911                                         //mt:32tou16
33912                                         PunchUses int32
33913                                 }))(obj)).DmgGroups {
33914                                         if err := pcall(func() {
33915                                                 (((*(*(struct {
33916                                                         //mt:if _ = %s; false
33917                                                         NonNil bool
33918
33919                                                         AttackCooldown float32
33920                                                         MaxDropLvl     int16
33921
33922                                                         //mt:len32
33923                                                         GroupCaps []ToolGroupCap
33924
33925                                                         //mt:len32
33926                                                         DmgGroups []Group
33927
33928                                                         //mt:32tou16
33929                                                         PunchUses int32
33930                                                 }))(obj)).DmgGroups)[local398]).serialize(w)
33931                                         }); err != nil {
33932                                                 if err == io.EOF {
33933                                                         chk(io.EOF)
33934                                                 }
33935                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
33936                                         }
33937                                 }
33938                                 {
33939                                         x := uint16((*(*(struct {
33940                                                 //mt:if _ = %s; false
33941                                                 NonNil bool
33942
33943                                                 AttackCooldown float32
33944                                                 MaxDropLvl     int16
33945
33946                                                 //mt:len32
33947                                                 GroupCaps []ToolGroupCap
33948
33949                                                 //mt:len32
33950                                                 DmgGroups []Group
33951
33952                                                 //mt:32tou16
33953                                                 PunchUses int32
33954                                         }))(obj)).PunchUses)
33955                                         write16(w, uint16(x))
33956                                 }
33957                         }
33958                 }
33959                 {
33960                         buf := w
33961                         w := ow
33962                         if len((buf.Bytes())) > math.MaxUint16 {
33963                                 chk(ErrTooLong)
33964                         }
33965                         {
33966                                 x := uint16(len((buf.Bytes())))
33967                                 write16(w, uint16(x))
33968                         }
33969                         {
33970                                 _, err := w.Write((buf.Bytes())[:])
33971                                 chk(err)
33972                         }
33973                 }
33974         }
33975 }
33976
33977 func (obj *ToolCaps) deserialize(r io.Reader) {
33978         if _ = (*(*(struct {
33979                 //mt:if _ = %s; false
33980                 NonNil bool
33981
33982                 AttackCooldown float32
33983                 MaxDropLvl     int16
33984
33985                 //mt:len32
33986                 GroupCaps []ToolGroupCap
33987
33988                 //mt:len32
33989                 DmgGroups []Group
33990
33991                 //mt:32tou16
33992                 PunchUses int32
33993         }))(obj)); false {
33994                 {
33995                         p := &(*(*(struct {
33996                                 //mt:if _ = %s; false
33997                                 NonNil bool
33998
33999                                 AttackCooldown float32
34000                                 MaxDropLvl     int16
34001
34002                                 //mt:len32
34003                                 GroupCaps []ToolGroupCap
34004
34005                                 //mt:len32
34006                                 DmgGroups []Group
34007
34008                                 //mt:32tou16
34009                                 PunchUses int32
34010                         }))(obj)).NonNil
34011                         switch n := read8(r); n {
34012                         case 0:
34013                                 *p = false
34014                         case 1:
34015                                 *p = true
34016                         default:
34017                                 chk(fmt.Errorf("invalid bool: %d", n))
34018                         }
34019
34020                 }
34021         }
34022         {
34023                 var n uint16
34024                 {
34025                         p := &n
34026                         *p = read16(r)
34027                 }
34028                 r := &io.LimitedReader{R: r, N: int64(n)}
34029                 if r.N > 0 {
34030                         (*(*(struct {
34031                                 //mt:if _ = %s; false
34032                                 NonNil bool
34033
34034                                 AttackCooldown float32
34035                                 MaxDropLvl     int16
34036
34037                                 //mt:len32
34038                                 GroupCaps []ToolGroupCap
34039
34040                                 //mt:len32
34041                                 DmgGroups []Group
34042
34043                                 //mt:32tou16
34044                                 PunchUses int32
34045                         }))(obj)).NonNil = true
34046                 } /**/
34047                 {
34048                         if (*(*(struct {
34049                                 //mt:if _ = %s; false
34050                                 NonNil bool
34051
34052                                 AttackCooldown float32
34053                                 MaxDropLvl     int16
34054
34055                                 //mt:len32
34056                                 GroupCaps []ToolGroupCap
34057
34058                                 //mt:len32
34059                                 DmgGroups []Group
34060
34061                                 //mt:32tou16
34062                                 PunchUses int32
34063                         }))(obj)).NonNil {
34064                                 {
34065                                         var local399 uint8
34066                                         local400 := uint8(5)
34067                                         {
34068                                                 p := &local399
34069                                                 *p = read8(r)
34070                                         }
34071                                         if local399 != local400 {
34072                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local399))
34073                                         }
34074                                 }
34075                                 {
34076                                         p := &(*(*(struct {
34077                                                 //mt:if _ = %s; false
34078                                                 NonNil bool
34079
34080                                                 AttackCooldown float32
34081                                                 MaxDropLvl     int16
34082
34083                                                 //mt:len32
34084                                                 GroupCaps []ToolGroupCap
34085
34086                                                 //mt:len32
34087                                                 DmgGroups []Group
34088
34089                                                 //mt:32tou16
34090                                                 PunchUses int32
34091                                         }))(obj)).AttackCooldown
34092                                         *p = math.Float32frombits(read32(r))
34093                                 }
34094                                 {
34095                                         p := &(*(*(struct {
34096                                                 //mt:if _ = %s; false
34097                                                 NonNil bool
34098
34099                                                 AttackCooldown float32
34100                                                 MaxDropLvl     int16
34101
34102                                                 //mt:len32
34103                                                 GroupCaps []ToolGroupCap
34104
34105                                                 //mt:len32
34106                                                 DmgGroups []Group
34107
34108                                                 //mt:32tou16
34109                                                 PunchUses int32
34110                                         }))(obj)).MaxDropLvl
34111                                         *p = int16(read16(r))
34112                                 }
34113                                 var local401 uint32
34114                                 {
34115                                         p := &local401
34116                                         *p = read32(r)
34117                                 }
34118                                 ((*(*(struct {
34119                                         //mt:if _ = %s; false
34120                                         NonNil bool
34121
34122                                         AttackCooldown float32
34123                                         MaxDropLvl     int16
34124
34125                                         //mt:len32
34126                                         GroupCaps []ToolGroupCap
34127
34128                                         //mt:len32
34129                                         DmgGroups []Group
34130
34131                                         //mt:32tou16
34132                                         PunchUses int32
34133                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local401)
34134                                 for local402 := range (*(*(struct {
34135                                         //mt:if _ = %s; false
34136                                         NonNil bool
34137
34138                                         AttackCooldown float32
34139                                         MaxDropLvl     int16
34140
34141                                         //mt:len32
34142                                         GroupCaps []ToolGroupCap
34143
34144                                         //mt:len32
34145                                         DmgGroups []Group
34146
34147                                         //mt:32tou16
34148                                         PunchUses int32
34149                                 }))(obj)).GroupCaps {
34150                                         if err := pcall(func() {
34151                                                 (((*(*(struct {
34152                                                         //mt:if _ = %s; false
34153                                                         NonNil bool
34154
34155                                                         AttackCooldown float32
34156                                                         MaxDropLvl     int16
34157
34158                                                         //mt:len32
34159                                                         GroupCaps []ToolGroupCap
34160
34161                                                         //mt:len32
34162                                                         DmgGroups []Group
34163
34164                                                         //mt:32tou16
34165                                                         PunchUses int32
34166                                                 }))(obj)).GroupCaps)[local402]).deserialize(r)
34167                                         }); err != nil {
34168                                                 if err == io.EOF {
34169                                                         chk(io.EOF)
34170                                                 }
34171                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.ToolGroupCap", err))
34172                                         }
34173                                 }
34174                                 var local403 uint32
34175                                 {
34176                                         p := &local403
34177                                         *p = read32(r)
34178                                 }
34179                                 ((*(*(struct {
34180                                         //mt:if _ = %s; false
34181                                         NonNil bool
34182
34183                                         AttackCooldown float32
34184                                         MaxDropLvl     int16
34185
34186                                         //mt:len32
34187                                         GroupCaps []ToolGroupCap
34188
34189                                         //mt:len32
34190                                         DmgGroups []Group
34191
34192                                         //mt:32tou16
34193                                         PunchUses int32
34194                                 }))(obj)).DmgGroups) = make([]Group, local403)
34195                                 for local404 := range (*(*(struct {
34196                                         //mt:if _ = %s; false
34197                                         NonNil bool
34198
34199                                         AttackCooldown float32
34200                                         MaxDropLvl     int16
34201
34202                                         //mt:len32
34203                                         GroupCaps []ToolGroupCap
34204
34205                                         //mt:len32
34206                                         DmgGroups []Group
34207
34208                                         //mt:32tou16
34209                                         PunchUses int32
34210                                 }))(obj)).DmgGroups {
34211                                         if err := pcall(func() {
34212                                                 (((*(*(struct {
34213                                                         //mt:if _ = %s; false
34214                                                         NonNil bool
34215
34216                                                         AttackCooldown float32
34217                                                         MaxDropLvl     int16
34218
34219                                                         //mt:len32
34220                                                         GroupCaps []ToolGroupCap
34221
34222                                                         //mt:len32
34223                                                         DmgGroups []Group
34224
34225                                                         //mt:32tou16
34226                                                         PunchUses int32
34227                                                 }))(obj)).DmgGroups)[local404]).deserialize(r)
34228                                         }); err != nil {
34229                                                 if err == io.EOF {
34230                                                         chk(io.EOF)
34231                                                 }
34232                                                 chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Group", err))
34233                                         }
34234                                 }
34235                                 var local405 uint16
34236                                 {
34237                                         p := &local405
34238                                         *p = read16(r)
34239                                 }
34240                                 (*(*(struct {
34241                                         //mt:if _ = %s; false
34242                                         NonNil bool
34243
34244                                         AttackCooldown float32
34245                                         MaxDropLvl     int16
34246
34247                                         //mt:len32
34248                                         GroupCaps []ToolGroupCap
34249
34250                                         //mt:len32
34251                                         DmgGroups []Group
34252
34253                                         //mt:32tou16
34254                                         PunchUses int32
34255                                 }))(obj)).PunchUses = int32(local405)
34256                         }
34257                 }
34258                 if r.N > 0 {
34259                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34260                 }
34261         }
34262 }
34263
34264 func (obj *AnimType) serialize(w io.Writer) {
34265         {
34266                 x := *(*(uint8))(obj)
34267                 write8(w, uint8(x))
34268         }
34269 }
34270
34271 func (obj *AnimType) deserialize(r io.Reader) {
34272         {
34273                 p := &*(*(uint8))(obj)
34274                 *p = read8(r)
34275         }
34276 }
34277
34278 func (obj *HUDType) serialize(w io.Writer) {
34279         {
34280                 x := *(*(uint8))(obj)
34281                 write8(w, uint8(x))
34282         }
34283 }
34284
34285 func (obj *HUDType) deserialize(r io.Reader) {
34286         {
34287                 p := &*(*(uint8))(obj)
34288                 *p = read8(r)
34289         }
34290 }
34291
34292 func (obj *Box) serialize(w io.Writer) {
34293         for local406 := range *(*([2]Vec))(obj) {
34294                 if err := pcall(func() {
34295                         ((*(*([2]Vec))(obj))[local406]).serialize(w)
34296                 }); err != nil {
34297                         if err == io.EOF {
34298                                 chk(io.EOF)
34299                         }
34300                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
34301                 }
34302         }
34303 }
34304
34305 func (obj *Box) deserialize(r io.Reader) {
34306         for local407 := range *(*([2]Vec))(obj) {
34307                 if err := pcall(func() {
34308                         ((*(*([2]Vec))(obj))[local407]).deserialize(r)
34309                 }); err != nil {
34310                         if err == io.EOF {
34311                                 chk(io.EOF)
34312                         }
34313                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Vec", err))
34314                 }
34315         }
34316 }
34317
34318 func (obj *TileFlags) serialize(w io.Writer) {
34319         {
34320                 x := *(*(uint16))(obj)
34321                 write16(w, uint16(x))
34322         }
34323 }
34324
34325 func (obj *TileFlags) deserialize(r io.Reader) {
34326         {
34327                 p := &*(*(uint16))(obj)
34328                 *p = read16(r)
34329         }
34330 }
34331
34332 func (obj *AlignType) serialize(w io.Writer) {
34333         {
34334                 x := *(*(uint8))(obj)
34335                 write8(w, uint8(x))
34336         }
34337 }
34338
34339 func (obj *AlignType) deserialize(r io.Reader) {
34340         {
34341                 p := &*(*(uint8))(obj)
34342                 *p = read8(r)
34343         }
34344 }
34345
34346 func (obj *NodeBoxType) serialize(w io.Writer) {
34347         {
34348                 x := *(*(uint8))(obj)
34349                 write8(w, uint8(x))
34350         }
34351 }
34352
34353 func (obj *NodeBoxType) deserialize(r io.Reader) {
34354         {
34355                 p := &*(*(uint8))(obj)
34356                 *p = read8(r)
34357         }
34358 }
34359
34360 func (obj *DirBoxes) serialize(w io.Writer) {
34361         if len(((*(*(struct {
34362                 Top, Bot                 []Box
34363                 Front, Left, Back, Right []Box
34364         }))(obj)).Top)) > math.MaxUint16 {
34365                 chk(ErrTooLong)
34366         }
34367         {
34368                 x := uint16(len(((*(*(struct {
34369                         Top, Bot                 []Box
34370                         Front, Left, Back, Right []Box
34371                 }))(obj)).Top)))
34372                 write16(w, uint16(x))
34373         }
34374         for local408 := range (*(*(struct {
34375                 Top, Bot                 []Box
34376                 Front, Left, Back, Right []Box
34377         }))(obj)).Top {
34378                 if err := pcall(func() {
34379                         (((*(*(struct {
34380                                 Top, Bot                 []Box
34381                                 Front, Left, Back, Right []Box
34382                         }))(obj)).Top)[local408]).serialize(w)
34383                 }); err != nil {
34384                         if err == io.EOF {
34385                                 chk(io.EOF)
34386                         }
34387                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34388                 }
34389         }
34390         if len(((*(*(struct {
34391                 Top, Bot                 []Box
34392                 Front, Left, Back, Right []Box
34393         }))(obj)).Bot)) > math.MaxUint16 {
34394                 chk(ErrTooLong)
34395         }
34396         {
34397                 x := uint16(len(((*(*(struct {
34398                         Top, Bot                 []Box
34399                         Front, Left, Back, Right []Box
34400                 }))(obj)).Bot)))
34401                 write16(w, uint16(x))
34402         }
34403         for local409 := range (*(*(struct {
34404                 Top, Bot                 []Box
34405                 Front, Left, Back, Right []Box
34406         }))(obj)).Bot {
34407                 if err := pcall(func() {
34408                         (((*(*(struct {
34409                                 Top, Bot                 []Box
34410                                 Front, Left, Back, Right []Box
34411                         }))(obj)).Bot)[local409]).serialize(w)
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         if len(((*(*(struct {
34420                 Top, Bot                 []Box
34421                 Front, Left, Back, Right []Box
34422         }))(obj)).Front)) > math.MaxUint16 {
34423                 chk(ErrTooLong)
34424         }
34425         {
34426                 x := uint16(len(((*(*(struct {
34427                         Top, Bot                 []Box
34428                         Front, Left, Back, Right []Box
34429                 }))(obj)).Front)))
34430                 write16(w, uint16(x))
34431         }
34432         for local410 := range (*(*(struct {
34433                 Top, Bot                 []Box
34434                 Front, Left, Back, Right []Box
34435         }))(obj)).Front {
34436                 if err := pcall(func() {
34437                         (((*(*(struct {
34438                                 Top, Bot                 []Box
34439                                 Front, Left, Back, Right []Box
34440                         }))(obj)).Front)[local410]).serialize(w)
34441                 }); err != nil {
34442                         if err == io.EOF {
34443                                 chk(io.EOF)
34444                         }
34445                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34446                 }
34447         }
34448         if len(((*(*(struct {
34449                 Top, Bot                 []Box
34450                 Front, Left, Back, Right []Box
34451         }))(obj)).Left)) > math.MaxUint16 {
34452                 chk(ErrTooLong)
34453         }
34454         {
34455                 x := uint16(len(((*(*(struct {
34456                         Top, Bot                 []Box
34457                         Front, Left, Back, Right []Box
34458                 }))(obj)).Left)))
34459                 write16(w, uint16(x))
34460         }
34461         for local411 := range (*(*(struct {
34462                 Top, Bot                 []Box
34463                 Front, Left, Back, Right []Box
34464         }))(obj)).Left {
34465                 if err := pcall(func() {
34466                         (((*(*(struct {
34467                                 Top, Bot                 []Box
34468                                 Front, Left, Back, Right []Box
34469                         }))(obj)).Left)[local411]).serialize(w)
34470                 }); err != nil {
34471                         if err == io.EOF {
34472                                 chk(io.EOF)
34473                         }
34474                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34475                 }
34476         }
34477         if len(((*(*(struct {
34478                 Top, Bot                 []Box
34479                 Front, Left, Back, Right []Box
34480         }))(obj)).Back)) > math.MaxUint16 {
34481                 chk(ErrTooLong)
34482         }
34483         {
34484                 x := uint16(len(((*(*(struct {
34485                         Top, Bot                 []Box
34486                         Front, Left, Back, Right []Box
34487                 }))(obj)).Back)))
34488                 write16(w, uint16(x))
34489         }
34490         for local412 := range (*(*(struct {
34491                 Top, Bot                 []Box
34492                 Front, Left, Back, Right []Box
34493         }))(obj)).Back {
34494                 if err := pcall(func() {
34495                         (((*(*(struct {
34496                                 Top, Bot                 []Box
34497                                 Front, Left, Back, Right []Box
34498                         }))(obj)).Back)[local412]).serialize(w)
34499                 }); err != nil {
34500                         if err == io.EOF {
34501                                 chk(io.EOF)
34502                         }
34503                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34504                 }
34505         }
34506         if len(((*(*(struct {
34507                 Top, Bot                 []Box
34508                 Front, Left, Back, Right []Box
34509         }))(obj)).Right)) > math.MaxUint16 {
34510                 chk(ErrTooLong)
34511         }
34512         {
34513                 x := uint16(len(((*(*(struct {
34514                         Top, Bot                 []Box
34515                         Front, Left, Back, Right []Box
34516                 }))(obj)).Right)))
34517                 write16(w, uint16(x))
34518         }
34519         for local413 := range (*(*(struct {
34520                 Top, Bot                 []Box
34521                 Front, Left, Back, Right []Box
34522         }))(obj)).Right {
34523                 if err := pcall(func() {
34524                         (((*(*(struct {
34525                                 Top, Bot                 []Box
34526                                 Front, Left, Back, Right []Box
34527                         }))(obj)).Right)[local413]).serialize(w)
34528                 }); err != nil {
34529                         if err == io.EOF {
34530                                 chk(io.EOF)
34531                         }
34532                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34533                 }
34534         }
34535 }
34536
34537 func (obj *DirBoxes) deserialize(r io.Reader) {
34538         var local414 uint16
34539         {
34540                 p := &local414
34541                 *p = read16(r)
34542         }
34543         ((*(*(struct {
34544                 Top, Bot                 []Box
34545                 Front, Left, Back, Right []Box
34546         }))(obj)).Top) = make([]Box, local414)
34547         for local415 := range (*(*(struct {
34548                 Top, Bot                 []Box
34549                 Front, Left, Back, Right []Box
34550         }))(obj)).Top {
34551                 if err := pcall(func() {
34552                         (((*(*(struct {
34553                                 Top, Bot                 []Box
34554                                 Front, Left, Back, Right []Box
34555                         }))(obj)).Top)[local415]).deserialize(r)
34556                 }); err != nil {
34557                         if err == io.EOF {
34558                                 chk(io.EOF)
34559                         }
34560                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34561                 }
34562         }
34563         var local416 uint16
34564         {
34565                 p := &local416
34566                 *p = read16(r)
34567         }
34568         ((*(*(struct {
34569                 Top, Bot                 []Box
34570                 Front, Left, Back, Right []Box
34571         }))(obj)).Bot) = make([]Box, local416)
34572         for local417 := range (*(*(struct {
34573                 Top, Bot                 []Box
34574                 Front, Left, Back, Right []Box
34575         }))(obj)).Bot {
34576                 if err := pcall(func() {
34577                         (((*(*(struct {
34578                                 Top, Bot                 []Box
34579                                 Front, Left, Back, Right []Box
34580                         }))(obj)).Bot)[local417]).deserialize(r)
34581                 }); err != nil {
34582                         if err == io.EOF {
34583                                 chk(io.EOF)
34584                         }
34585                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34586                 }
34587         }
34588         var local418 uint16
34589         {
34590                 p := &local418
34591                 *p = read16(r)
34592         }
34593         ((*(*(struct {
34594                 Top, Bot                 []Box
34595                 Front, Left, Back, Right []Box
34596         }))(obj)).Front) = make([]Box, local418)
34597         for local419 := range (*(*(struct {
34598                 Top, Bot                 []Box
34599                 Front, Left, Back, Right []Box
34600         }))(obj)).Front {
34601                 if err := pcall(func() {
34602                         (((*(*(struct {
34603                                 Top, Bot                 []Box
34604                                 Front, Left, Back, Right []Box
34605                         }))(obj)).Front)[local419]).deserialize(r)
34606                 }); err != nil {
34607                         if err == io.EOF {
34608                                 chk(io.EOF)
34609                         }
34610                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34611                 }
34612         }
34613         var local420 uint16
34614         {
34615                 p := &local420
34616                 *p = read16(r)
34617         }
34618         ((*(*(struct {
34619                 Top, Bot                 []Box
34620                 Front, Left, Back, Right []Box
34621         }))(obj)).Left) = make([]Box, local420)
34622         for local421 := range (*(*(struct {
34623                 Top, Bot                 []Box
34624                 Front, Left, Back, Right []Box
34625         }))(obj)).Left {
34626                 if err := pcall(func() {
34627                         (((*(*(struct {
34628                                 Top, Bot                 []Box
34629                                 Front, Left, Back, Right []Box
34630                         }))(obj)).Left)[local421]).deserialize(r)
34631                 }); err != nil {
34632                         if err == io.EOF {
34633                                 chk(io.EOF)
34634                         }
34635                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34636                 }
34637         }
34638         var local422 uint16
34639         {
34640                 p := &local422
34641                 *p = read16(r)
34642         }
34643         ((*(*(struct {
34644                 Top, Bot                 []Box
34645                 Front, Left, Back, Right []Box
34646         }))(obj)).Back) = make([]Box, local422)
34647         for local423 := range (*(*(struct {
34648                 Top, Bot                 []Box
34649                 Front, Left, Back, Right []Box
34650         }))(obj)).Back {
34651                 if err := pcall(func() {
34652                         (((*(*(struct {
34653                                 Top, Bot                 []Box
34654                                 Front, Left, Back, Right []Box
34655                         }))(obj)).Back)[local423]).deserialize(r)
34656                 }); err != nil {
34657                         if err == io.EOF {
34658                                 chk(io.EOF)
34659                         }
34660                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34661                 }
34662         }
34663         var local424 uint16
34664         {
34665                 p := &local424
34666                 *p = read16(r)
34667         }
34668         ((*(*(struct {
34669                 Top, Bot                 []Box
34670                 Front, Left, Back, Right []Box
34671         }))(obj)).Right) = make([]Box, local424)
34672         for local425 := range (*(*(struct {
34673                 Top, Bot                 []Box
34674                 Front, Left, Back, Right []Box
34675         }))(obj)).Right {
34676                 if err := pcall(func() {
34677                         (((*(*(struct {
34678                                 Top, Bot                 []Box
34679                                 Front, Left, Back, Right []Box
34680                         }))(obj)).Right)[local425]).deserialize(r)
34681                 }); err != nil {
34682                         if err == io.EOF {
34683                                 chk(io.EOF)
34684                         }
34685                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.Box", err))
34686                 }
34687         }
34688 }
34689
34690 func (obj *ToolGroupCap) serialize(w io.Writer) {
34691         if len(([]byte((*(*(struct {
34692                 Name string
34693
34694                 //mt:32to16
34695                 Uses int32
34696
34697                 MaxLvl int16
34698
34699                 //mt:len32
34700                 Times []DigTime
34701         }))(obj)).Name))) > math.MaxUint16 {
34702                 chk(ErrTooLong)
34703         }
34704         {
34705                 x := uint16(len(([]byte((*(*(struct {
34706                         Name string
34707
34708                         //mt:32to16
34709                         Uses int32
34710
34711                         MaxLvl int16
34712
34713                         //mt:len32
34714                         Times []DigTime
34715                 }))(obj)).Name))))
34716                 write16(w, uint16(x))
34717         }
34718         {
34719                 _, err := w.Write(([]byte((*(*(struct {
34720                         Name string
34721
34722                         //mt:32to16
34723                         Uses int32
34724
34725                         MaxLvl int16
34726
34727                         //mt:len32
34728                         Times []DigTime
34729                 }))(obj)).Name))[:])
34730                 chk(err)
34731         }
34732         {
34733                 x := int16((*(*(struct {
34734                         Name string
34735
34736                         //mt:32to16
34737                         Uses int32
34738
34739                         MaxLvl int16
34740
34741                         //mt:len32
34742                         Times []DigTime
34743                 }))(obj)).Uses)
34744                 write16(w, uint16(x))
34745         }
34746         {
34747                 x := (*(*(struct {
34748                         Name string
34749
34750                         //mt:32to16
34751                         Uses int32
34752
34753                         MaxLvl int16
34754
34755                         //mt:len32
34756                         Times []DigTime
34757                 }))(obj)).MaxLvl
34758                 write16(w, uint16(x))
34759         }
34760         if len(((*(*(struct {
34761                 Name string
34762
34763                 //mt:32to16
34764                 Uses int32
34765
34766                 MaxLvl int16
34767
34768                 //mt:len32
34769                 Times []DigTime
34770         }))(obj)).Times)) > math.MaxUint32 {
34771                 chk(ErrTooLong)
34772         }
34773         {
34774                 x := uint32(len(((*(*(struct {
34775                         Name string
34776
34777                         //mt:32to16
34778                         Uses int32
34779
34780                         MaxLvl int16
34781
34782                         //mt:len32
34783                         Times []DigTime
34784                 }))(obj)).Times)))
34785                 write32(w, uint32(x))
34786         }
34787         for local426 := range (*(*(struct {
34788                 Name string
34789
34790                 //mt:32to16
34791                 Uses int32
34792
34793                 MaxLvl int16
34794
34795                 //mt:len32
34796                 Times []DigTime
34797         }))(obj)).Times {
34798                 if err := pcall(func() {
34799                         (((*(*(struct {
34800                                 Name string
34801
34802                                 //mt:32to16
34803                                 Uses int32
34804
34805                                 MaxLvl int16
34806
34807                                 //mt:len32
34808                                 Times []DigTime
34809                         }))(obj)).Times)[local426]).serialize(w)
34810                 }); err != nil {
34811                         if err == io.EOF {
34812                                 chk(io.EOF)
34813                         }
34814                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DigTime", err))
34815                 }
34816         }
34817 }
34818
34819 func (obj *ToolGroupCap) deserialize(r io.Reader) {
34820         var local427 []uint8
34821         var local428 uint16
34822         {
34823                 p := &local428
34824                 *p = read16(r)
34825         }
34826         (local427) = make([]uint8, local428)
34827         {
34828                 _, err := io.ReadFull(r, (local427)[:])
34829                 chk(err)
34830         }
34831         ((*(*(struct {
34832                 Name string
34833
34834                 //mt:32to16
34835                 Uses int32
34836
34837                 MaxLvl int16
34838
34839                 //mt:len32
34840                 Times []DigTime
34841         }))(obj)).Name) = string(local427)
34842         var local429 int16
34843         {
34844                 p := &local429
34845                 *p = int16(read16(r))
34846         }
34847         (*(*(struct {
34848                 Name string
34849
34850                 //mt:32to16
34851                 Uses int32
34852
34853                 MaxLvl int16
34854
34855                 //mt:len32
34856                 Times []DigTime
34857         }))(obj)).Uses = int32(local429)
34858         {
34859                 p := &(*(*(struct {
34860                         Name string
34861
34862                         //mt:32to16
34863                         Uses int32
34864
34865                         MaxLvl int16
34866
34867                         //mt:len32
34868                         Times []DigTime
34869                 }))(obj)).MaxLvl
34870                 *p = int16(read16(r))
34871         }
34872         var local430 uint32
34873         {
34874                 p := &local430
34875                 *p = read32(r)
34876         }
34877         ((*(*(struct {
34878                 Name string
34879
34880                 //mt:32to16
34881                 Uses int32
34882
34883                 MaxLvl int16
34884
34885                 //mt:len32
34886                 Times []DigTime
34887         }))(obj)).Times) = make([]DigTime, local430)
34888         for local431 := range (*(*(struct {
34889                 Name string
34890
34891                 //mt:32to16
34892                 Uses int32
34893
34894                 MaxLvl int16
34895
34896                 //mt:len32
34897                 Times []DigTime
34898         }))(obj)).Times {
34899                 if err := pcall(func() {
34900                         (((*(*(struct {
34901                                 Name string
34902
34903                                 //mt:32to16
34904                                 Uses int32
34905
34906                                 MaxLvl int16
34907
34908                                 //mt:len32
34909                                 Times []DigTime
34910                         }))(obj)).Times)[local431]).deserialize(r)
34911                 }); err != nil {
34912                         if err == io.EOF {
34913                                 chk(io.EOF)
34914                         }
34915                         chk(fmt.Errorf("%s: %w", "github.com/Minetest-j45/mt.DigTime", err))
34916                 }
34917         }
34918 }
34919
34920 func (obj *DigTime) serialize(w io.Writer) {
34921         {
34922                 x := (*(*(struct {
34923                         Rating int16
34924                         Time   float32
34925                 }))(obj)).Rating
34926                 write16(w, uint16(x))
34927         }
34928         {
34929                 x := (*(*(struct {
34930                         Rating int16
34931                         Time   float32
34932                 }))(obj)).Time
34933                 write32(w, math.Float32bits(x))
34934         }
34935 }
34936
34937 func (obj *DigTime) deserialize(r io.Reader) {
34938         {
34939                 p := &(*(*(struct {
34940                         Rating int16
34941                         Time   float32
34942                 }))(obj)).Rating
34943                 *p = int16(read16(r))
34944         }
34945         {
34946                 p := &(*(*(struct {
34947                         Rating int16
34948                         Time   float32
34949                 }))(obj)).Time
34950                 *p = math.Float32frombits(read32(r))
34951         }
34952 }