minego/pkg/protocol/component/codecs.go

// Code generated by github.com/go-mc/packetizer; DO NOT EDIT.

package component

import (
	"errors"
	"io"

	"git.konjactw.dev/falloutBot/go-mc/net/packet"
)

func (c *AttributeModifiers) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Modifiers).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c AttributeModifiers) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Modifiers).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *AttributeModifier) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.AttributeID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Identifier)(&c.ModifierID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Double)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Operation).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Slot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c AttributeModifier) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.AttributeID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Identifier)(&c.ModifierID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Double)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Operation).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Slot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *AxolotlVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c AxolotlVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BannerPatterns) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Layers).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BannerPatterns) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Layers).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BannerLayer) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Pattern).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.Pattern == 0 {
		temp, err = (&c.AssetID).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Pattern == 0 {
		temp, err = (*packet.String)(&c.TranslationKey).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BannerLayer) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Pattern).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.Pattern == 0 {
		temp, err = (&c.AssetID).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Pattern == 0 {
		temp, err = (*packet.String)(&c.TranslationKey).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *DyeColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.ColorID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DyeColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.ColorID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BaseColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BaseColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Bees) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Bees).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Bees) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Bees).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Bee) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.EntityData).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.TicksInHive).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.MinTicksInHive).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Bee) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.EntityData).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.TicksInHive).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.MinTicksInHive).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BlockEntityData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockEntityData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BlockState) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Properties).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockState) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Properties).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BlockStateProperty) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockStateProperty) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BlocksAttacks) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.BlockDelaySeconds).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.DisableCooldownScale).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.DamageReductions).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.ItemDamageThreshold).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.ItemDamageBase).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.ItemDamageFactor).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.BypassedBy).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasBlockSound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasBlockSound {
		temp, err = (*packet.VarInt)(&c.BlockSoundID).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.HasBlockSound {
		if c.BlockSoundID == 0 {
			temp, err = (&c.BlockSound).ReadFrom(r)
			n += temp
			if err != nil {
				return n, err
			}
		}
	}
	temp, err = (*packet.Boolean)(&c.HasDisableSound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasDisableSound {
		temp, err = (*packet.VarInt)(&c.DisableSoundID).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.HasDisableSound {
		if c.DisableSoundID == 0 {
			temp, err = (&c.DisableSound).ReadFrom(r)
			n += temp
			if err != nil {
				return n, err
			}
		}
	}
	return n, err
}

func (c BlocksAttacks) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.BlockDelaySeconds).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.DisableCooldownScale).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.DamageReductions).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.ItemDamageThreshold).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.ItemDamageBase).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.ItemDamageFactor).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.BypassedBy).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasBlockSound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasBlockSound {
		temp, err = (*packet.VarInt)(&c.BlockSoundID).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.HasBlockSound {
		if c.BlockSoundID == 0 {
			temp, err = (&c.BlockSound).WriteTo(w)
			n += temp
			if err != nil {
				return n, err
			}
		}
	}
	temp, err = (*packet.Boolean)(&c.HasDisableSound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasDisableSound {
		temp, err = (*packet.VarInt)(&c.DisableSoundID).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.HasDisableSound {
		if c.DisableSoundID == 0 {
			temp, err = (&c.DisableSound).WriteTo(w)
			n += temp
			if err != nil {
				return n, err
			}
		}
	}
	return n, err
}
func (c *DamageReduction) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.HorizontalBlockingAngle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasType {
		temp, err = (&c.Type).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Float)(&c.Base).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.Factor).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DamageReduction) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.HorizontalBlockingAngle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasType {
		temp, err = (&c.Type).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Float)(&c.Base).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.Factor).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BreakSound) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundData).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BreakSound) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundData).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BucketEntityData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BucketEntityData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BundleContents) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Items).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BundleContents) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Items).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CanBreak) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.BlockPredicates).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CanBreak) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.BlockPredicates).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CanPlaceOn) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.BlockPredicates).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CanPlaceOn) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.BlockPredicates).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *BlockPredicate) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Blocks).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Properties).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.NBT).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.DataComponents).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.PartialDataComponentPredicates).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockPredicate) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Blocks).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Properties).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.NBT).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.DataComponents).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.PartialDataComponentPredicates).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Property) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.IsExactMatch).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.ExactValue).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.MinValue).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.MaxValue).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Property) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.IsExactMatch).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.ExactValue).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.MinValue).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.MaxValue).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ExactDataComponentMatcher) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.NBT(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ExactDataComponentMatcher) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.NBT(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PartialDataComponentMatcher) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.NBT(&c.Predicate).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PartialDataComponentMatcher) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.NBT(&c.Predicate).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CatCollar) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CatCollar) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CatVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CatVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ChargedProjectiles) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Projectiles).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ChargedProjectiles) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Projectiles).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Consumable) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.ConsumeSeconds).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Animation).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.SoundID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.SoundID == 0 {
		c.SoundEvent = new(SoundEvent)
		temp, err = (*SoundEvent)(c.SoundEvent).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasConsumeParticles).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Effects).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Consumable) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.ConsumeSeconds).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Animation).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.SoundID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.SoundID == 0 {
		temp, err = (*SoundEvent)(c.SoundEvent).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasConsumeParticles).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Effects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *SoundEvent) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundEventID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFixedRange).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasFixedRange {
		temp, err = (*packet.Float)(&c.FixedRange).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	return n, err
}

func (c SoundEvent) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundEventID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFixedRange).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasFixedRange {
		temp, err = (*packet.Float)(&c.FixedRange).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	return n, err
}
func (c *ConsumeEffect) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.Type == 0 {
		temp, err = packet.Array(&c.ApplyEffects).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 0 {
		temp, err = (*packet.Float)(&c.ApplyProbability).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 1 {
		temp, err = (&c.RemoveEffects).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 3 {
		temp, err = (*packet.Float)(&c.TeleportRandomlyDiameter).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 4 {
		temp, err = (&c.PlaySound).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	return n, err
}

func (c ConsumeEffect) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.Type == 0 {
		temp, err = packet.Array(&c.ApplyEffects).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 0 {
		temp, err = (*packet.Float)(&c.ApplyProbability).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 1 {
		temp, err = (&c.RemoveEffects).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 3 {
		temp, err = (*packet.Float)(&c.TeleportRandomlyDiameter).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	if c.Type == 4 {
		temp, err = (&c.PlaySound).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	return n, err
}
func (c *Container) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Items).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Container) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Items).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ContainerLoot) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ContainerLoot) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CowVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CowVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CreativeSlotLock) ReadFrom(r io.Reader) (n int64, err error) {
	return 0, nil
}

func (c CreativeSlotLock) WriteTo(w io.Writer) (n int64, err error) {
	return 0, nil
}
func (c *CustomData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CustomData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CustomModelData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*Float32VarIntArray)(&c.Floats).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*BoolVarIntArray)(&c.Flags).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*StringVarIntArray)(&c.Strings).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntVarIntArray)(&c.Colors).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CustomModelData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*Float32VarIntArray)(&c.Floats).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*BoolVarIntArray)(&c.Flags).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*StringVarIntArray)(&c.Strings).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntVarIntArray)(&c.Colors).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *CustomName) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CustomName) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Damage) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Damage).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Damage) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Damage).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *DamageResistant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Types).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DamageResistant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Types).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *DeathProtection) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Effects).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DeathProtection) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Effects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *DebugStickState) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DebugStickState) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *DyedColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Int)(&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DyedColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Int)(&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Enchantable) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Enchantable) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *EnchantmentGlintOverride) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasGlint).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c EnchantmentGlintOverride) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasGlint).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Enchantments) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Enchantments).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Enchantments) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Enchantments).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Enchantment) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Level).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Enchantment) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Level).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *EntityData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c EntityData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Equippable) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Slot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.EquipSoundID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.EquipSoundID == 0 {
		c.EquipSoundEvent = new(SoundEvent)
		temp, err = (*SoundEvent)(c.EquipSoundEvent).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasModel).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasModel {
		temp, err = (*packet.Identifier)(&c.Model).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasCameraOverlay).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasCameraOverlay {
		temp, err = (*packet.Identifier)(&c.CameraOverlay).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasAllowedEntities).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasAllowedEntities {
		temp, err = (&c.AllowedEntitiesID).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.Dispensable).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Swappable).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.DamageOnHurt).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Equippable) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Slot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.EquipSoundID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.EquipSoundID == 0 {
		temp, err = (*SoundEvent)(c.EquipSoundEvent).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasModel).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasModel {
		temp, err = (*packet.Identifier)(&c.Model).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasCameraOverlay).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasCameraOverlay {
		temp, err = (*packet.Identifier)(&c.CameraOverlay).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.HasAllowedEntities).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasAllowedEntities {
		temp, err = (&c.AllowedEntitiesID).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	temp, err = (*packet.Boolean)(&c.Dispensable).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Swappable).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.DamageOnHurt).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *FireworkExplosion) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Explosion).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c FireworkExplosion) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Explosion).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *FireworkExplosionData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Shape).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntArray)(&c.Colors).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntArray)(&c.FadeColors).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasTrail).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasTwinkle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c FireworkExplosionData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Shape).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntArray)(&c.Colors).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntArray)(&c.FadeColors).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasTrail).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasTwinkle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Fireworks) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.FlightDuration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Explosions).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Fireworks) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.FlightDuration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Explosions).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Food) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Nutrition).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.SaturationModifier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.CanAlwaysEat).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Food) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Nutrition).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.SaturationModifier).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.CanAlwaysEat).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *FoxVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c FoxVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *FrogVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c FrogVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Glider) ReadFrom(r io.Reader) (n int64, err error) {
	return 0, nil
}

func (c Glider) WriteTo(w io.Writer) (n int64, err error) {
	return 0, nil
}
func (c *HorseVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c HorseVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Instrument) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Instrument).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Instrument) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Instrument).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *InstrumentData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundEvent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.SoundRange).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.Range).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c InstrumentData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundEvent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.SoundRange).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.Range).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *IntangibleProjectile) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Empty).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c IntangibleProjectile) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Empty).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ItemModel) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Model).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ItemModel) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Model).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ItemName) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ItemName) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *JukeboxSongData) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundEvent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.Duration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Output).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c JukeboxSongData) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.SoundEvent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.Duration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Output).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *LlamaVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c LlamaVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Lock) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Key).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Lock) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Key).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *LodestoneTracker) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasGlobalPosition).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Dimension).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Position).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Tracked).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c LodestoneTracker) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasGlobalPosition).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Dimension).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Position).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Tracked).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Lore) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Lines).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Lore) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Lines).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MapColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Int)(&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MapColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Int)(&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MapDecorations) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MapDecorations) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MapID) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.MapID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MapID) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.MapID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MapPostProcessing) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.PostProcessingType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MapPostProcessing) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.PostProcessingType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MaxDamage) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Damage).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MaxDamage) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Damage).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MaxStackSize) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Size).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MaxStackSize) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Size).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *MooshroomVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MooshroomVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *NoteBlockSound) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Sound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c NoteBlockSound) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Sound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *OminousBottleAmplifier) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Amplifier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c OminousBottleAmplifier) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Amplifier).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PaintingVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Int)(&c.Width).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Int)(&c.Height).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.AssetID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Title).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Author).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PaintingVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Int)(&c.Width).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Int)(&c.Height).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.AssetID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Title).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Author).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ParrotVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ParrotVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PigVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PigVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PotDecorations) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*Int32PrefixedArrayVarIntArray)(&c.Decorations).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PotDecorations) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*Int32PrefixedArrayVarIntArray)(&c.Decorations).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PotionContents) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasPotionID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.PotionID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasCustomColor).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Int)(&c.CustomColor).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.CustomEffects).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.CustomName).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PotionContents) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasPotionID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.PotionID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasCustomColor).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Int)(&c.CustomColor).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.CustomEffects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.CustomName).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PotionEffect) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.TypeID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Details).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PotionEffect) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.TypeID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Details).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *PotionEffectDetails) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Amplifier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Duration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Ambient).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.ShowParticles).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.ShowIcon).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasHiddenEffect).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasHiddenEffect {
		c.HiddenEffect = new(PotionEffect)
		temp, err = (*PotionEffect)(c.HiddenEffect).ReadFrom(r)
		n += temp
		if err != nil {
			return n, err
		}
	}
	return n, err
}

func (c PotionEffectDetails) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Amplifier).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Duration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Ambient).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.ShowParticles).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.ShowIcon).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasHiddenEffect).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	if c.HasHiddenEffect {
		temp, err = (*PotionEffect)(c.HiddenEffect).WriteTo(w)
		n += temp
		if err != nil {
			return n, err
		}
	}
	return n, err
}
func (c *PotionDurationScale) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.EffectMultiplier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PotionDurationScale) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.EffectMultiplier).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Profile) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasName).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasUniqueID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.UniqueID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Properties).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Profile) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HasName).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasUniqueID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.UniqueID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Properties).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ProfileProperty) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasSignature).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Signature).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ProfileProperty) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasSignature).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Signature).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ProvidesBannerPatterns) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Key).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ProvidesBannerPatterns) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Key).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *RabbitVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c RabbitVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Rarity) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Rarity).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Rarity) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Rarity).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Recipes) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Recipes) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *RepairCost) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Cost).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c RepairCost) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Cost).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Repairable) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Items).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Repairable) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Items).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *SalmonSize) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.SizeType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c SalmonSize) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.SizeType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *SheepColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c SheepColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ShulkerColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ShulkerColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *StoredEnchantments) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Enchantments).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c StoredEnchantments) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Enchantments).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *SuspiciousStewEffects) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Effects).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c SuspiciousStewEffects) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Effects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *SuspiciousStewEffect) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.TypeID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Duration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c SuspiciousStewEffect) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.TypeID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Duration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Tool) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Rules).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.DefaultMiningSpeed).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.DamagePerBlock).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Tool) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Rules).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.DefaultMiningSpeed).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.DamagePerBlock).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *ToolRule) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Blocks).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasSpeed).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Speed).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasCorrectDropForBlocks).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CorrectDropForBlocks).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ToolRule) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Blocks).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasSpeed).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Speed).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasCorrectDropForBlocks).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CorrectDropForBlocks).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TooltipDisplay) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HideTooltip).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntVarIntArray)(&c.HiddenComponents).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TooltipDisplay) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Boolean)(&c.HideTooltip).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*Int32VarIntVarIntArray)(&c.HiddenComponents).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TooltipStyle) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Style).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TooltipStyle) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Style).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Trim) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.TrimMaterial).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.TrimPattern).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Trim) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.TrimMaterial).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.TrimPattern).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TrimMaterial) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Suffix).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Overrides).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TrimMaterial) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.Suffix).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Overrides).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TrimOverride) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.MaterialType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.OverrideAssetName).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TrimOverride) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.MaterialType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.OverrideAssetName).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TrimPattern) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.AssetName).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.TemplateItem).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Decal).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TrimPattern) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.AssetName).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.TemplateItem).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Description).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.Decal).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TropicalFishBaseColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TropicalFishBaseColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TropicalFishPattern) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Pattern).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TropicalFishPattern) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Pattern).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *TropicalFishPatternColor) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TropicalFishPatternColor) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Unbreakable) ReadFrom(r io.Reader) (n int64, err error) {
	return 0, nil
}

func (c Unbreakable) WriteTo(w io.Writer) (n int64, err error) {
	return 0, nil
}
func (c *UseCooldown) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.Seconds).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CooldownGroup).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c UseCooldown) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.Float)(&c.Seconds).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CooldownGroup).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *UseRemainder) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Remainder).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c UseRemainder) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Remainder).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *VillagerVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c VillagerVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *Weapon) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.DamagePerAttack).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.DisableBlockingFor).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Weapon) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.DamagePerAttack).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Float)(&c.DisableBlockingFor).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WolfCollar) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WolfCollar) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WolfSoundVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WolfSoundVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WolfVariant) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WolfVariant) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WritableBookContent) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Pages).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WritableBookContent) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = packet.Array(&c.Pages).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WritableBookPage) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.RawContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFilteredContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FilteredContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WritableBookPage) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.RawContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFilteredContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FilteredContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WrittenBookContent) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.RawTitle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFilteredTitle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FilteredTitle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.Author).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Generation).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Pages).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WrittenBookContent) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (*packet.String)(&c.RawTitle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFilteredTitle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FilteredTitle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.String)(&c.Author).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.VarInt)(&c.Generation).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = packet.Array(&c.Pages).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}
func (c *WrittenBookPage) ReadFrom(r io.Reader) (n int64, err error) {
	var temp int64
	temp, err = (&c.RawContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFilteredContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FilteredContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WrittenBookPage) WriteTo(w io.Writer) (n int64, err error) {
	var temp int64
	temp, err = (&c.RawContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*packet.Boolean)(&c.HasFilteredContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FilteredContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

// Int32VarIntArray a utility type for encoding/decoding packet.Int -> int32[packet.VarInt] slice.
type Int32VarIntArray []int32

func (a Int32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
	size := len(a)
	nn, err := packet.VarInt(size).WriteTo(w)
	if err != nil {
		return n, err
	}
	n += nn
	for i := 0; i < size; i++ {
		nn, err := packet.Int(a[i]).WriteTo(w)
		n += nn
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (a *Int32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
	var size packet.VarInt
	nn, err := size.ReadFrom(r)
	n += nn
	if err != nil {
		return n, err
	}
	if size < 0 {
		return n, errors.New("array length less than zero")
	}

	if cap(*a) >= int(size) {
		*a = (*a)[:int(size)]
	} else {
		*a = make(Int32VarIntArray, int(size))
	}

	for i := 0; i < int(size); i++ {
		nn, err = (*packet.Int)(&(*a)[i]).ReadFrom(r)
		n += nn
		if err != nil {
			return n, err
		}
	}

	return n, err
}

// Int32PrefixedArrayVarIntArray a utility type for encoding/decoding packet.Int -> int32[packet.VarInt] slice.
type Int32PrefixedArrayVarIntArray []int32

func (a Int32PrefixedArrayVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
	size := len(a)
	nn, err := packet.VarInt(size).WriteTo(w)
	if err != nil {
		return n, err
	}
	n += nn
	for i := 0; i < size; i++ {
		nn, err := packet.Int(a[i]).WriteTo(w)
		n += nn
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (a *Int32PrefixedArrayVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
	var size packet.VarInt
	nn, err := size.ReadFrom(r)
	n += nn
	if err != nil {
		return n, err
	}
	if size < 0 {
		return n, errors.New("array length less than zero")
	}

	if cap(*a) >= int(size) {
		*a = (*a)[:int(size)]
	} else {
		*a = make(Int32PrefixedArrayVarIntArray, int(size))
	}

	for i := 0; i < int(size); i++ {
		nn, err = (*packet.Int)(&(*a)[i]).ReadFrom(r)
		n += nn
		if err != nil {
			return n, err
		}
	}

	return n, err
}

// Float32VarIntArray a utility type for encoding/decoding packet.Float -> float32[packet.VarInt] slice.
type Float32VarIntArray []float32

func (a Float32VarIntArray) WriteTo(w io.Writer) (n int64, err error) {
	size := len(a)
	nn, err := packet.VarInt(size).WriteTo(w)
	if err != nil {
		return n, err
	}
	n += nn
	for i := 0; i < size; i++ {
		nn, err := packet.Float(a[i]).WriteTo(w)
		n += nn
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (a *Float32VarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
	var size packet.VarInt
	nn, err := size.ReadFrom(r)
	n += nn
	if err != nil {
		return n, err
	}
	if size < 0 {
		return n, errors.New("array length less than zero")
	}

	if cap(*a) >= int(size) {
		*a = (*a)[:int(size)]
	} else {
		*a = make(Float32VarIntArray, int(size))
	}

	for i := 0; i < int(size); i++ {
		nn, err = (*packet.Float)(&(*a)[i]).ReadFrom(r)
		n += nn
		if err != nil {
			return n, err
		}
	}

	return n, err
}

// BoolVarIntArray a utility type for encoding/decoding packet.Boolean -> bool[packet.VarInt] slice.
type BoolVarIntArray []bool

func (a BoolVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
	size := len(a)
	nn, err := packet.VarInt(size).WriteTo(w)
	if err != nil {
		return n, err
	}
	n += nn
	for i := 0; i < size; i++ {
		nn, err := packet.Boolean(a[i]).WriteTo(w)
		n += nn
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (a *BoolVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
	var size packet.VarInt
	nn, err := size.ReadFrom(r)
	n += nn
	if err != nil {
		return n, err
	}
	if size < 0 {
		return n, errors.New("array length less than zero")
	}

	if cap(*a) >= int(size) {
		*a = (*a)[:int(size)]
	} else {
		*a = make(BoolVarIntArray, int(size))
	}

	for i := 0; i < int(size); i++ {
		nn, err = (*packet.Boolean)(&(*a)[i]).ReadFrom(r)
		n += nn
		if err != nil {
			return n, err
		}
	}

	return n, err
}

// StringVarIntArray a utility type for encoding/decoding packet.String -> string[packet.VarInt] slice.
type StringVarIntArray []string

func (a StringVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
	size := len(a)
	nn, err := packet.VarInt(size).WriteTo(w)
	if err != nil {
		return n, err
	}
	n += nn
	for i := 0; i < size; i++ {
		nn, err := packet.String(a[i]).WriteTo(w)
		n += nn
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (a *StringVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
	var size packet.VarInt
	nn, err := size.ReadFrom(r)
	n += nn
	if err != nil {
		return n, err
	}
	if size < 0 {
		return n, errors.New("array length less than zero")
	}

	if cap(*a) >= int(size) {
		*a = (*a)[:int(size)]
	} else {
		*a = make(StringVarIntArray, int(size))
	}

	for i := 0; i < int(size); i++ {
		nn, err = (*packet.String)(&(*a)[i]).ReadFrom(r)
		n += nn
		if err != nil {
			return n, err
		}
	}

	return n, err
}

// Int32VarIntVarIntArray a utility type for encoding/decoding packet.VarInt -> int32[packet.VarInt] slice.
type Int32VarIntVarIntArray []int32

func (a Int32VarIntVarIntArray) WriteTo(w io.Writer) (n int64, err error) {
	size := len(a)
	nn, err := packet.VarInt(size).WriteTo(w)
	if err != nil {
		return n, err
	}
	n += nn
	for i := 0; i < size; i++ {
		nn, err := packet.VarInt(a[i]).WriteTo(w)
		n += nn
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

func (a *Int32VarIntVarIntArray) ReadFrom(r io.Reader) (n int64, err error) {
	var size packet.VarInt
	nn, err := size.ReadFrom(r)
	n += nn
	if err != nil {
		return n, err
	}
	if size < 0 {
		return n, errors.New("array length less than zero")
	}

	if cap(*a) >= int(size) {
		*a = (*a)[:int(size)]
	} else {
		*a = make(Int32VarIntVarIntArray, int(size))
	}

	for i := 0; i < int(size); i++ {
		nn, err = (*packet.VarInt)(&(*a)[i]).ReadFrom(r)
		n += nn
		if err != nil {
			return n, err
		}
	}

	return n, err
}