// Code generated by packetizer.go; DO NOT EDIT.

package component

import (
	"io"

	pk "github.com/Tnze/go-mc/net/packet"
)

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

func (c AttributeModifiers) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Modifiers).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *AxolotlVariant) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c AxolotlVariant) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c BannerPatterns) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Layers).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *BannerLayer) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.PatternType).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.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.PatternType).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.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.ColorID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c *BaseColor) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Bees).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Bees) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Bees).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *BlockEntityData) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockEntityData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c BlockState) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Properties).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *BlockStateProperty) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.String)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockStateProperty) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.String)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *BlocksAttacks) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.BlockDelaySeconds).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.DisableCooldownScale).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.DamageReductions).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.ItemDamageThreshold).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.ItemDamageBase).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (&c.BlockSound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.DisableSound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlocksAttacks) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.BlockDelaySeconds).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.DisableCooldownScale).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.DamageReductions).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.ItemDamageThreshold).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.ItemDamageBase).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (&c.BlockSound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.DisableSound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *DamageReduction) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.HorizontalBlockingAngle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Base).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Factor).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DamageReduction) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.HorizontalBlockingAngle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Base).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Factor).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *BreakSound) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BucketEntityData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c BundleContents) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Items).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

func (c *BlockPredicate) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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 = pk.Array(&c.DataComponents).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.PartialDataComponentPredicates).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BlockPredicate) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var 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 = pk.Array(&c.DataComponents).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.PartialDataComponentPredicates).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Property) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.NBT(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

func (c *CatCollar) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c ChargedProjectiles) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Projectiles).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Consumable) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.ConsumeSeconds).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Animation).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Sound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasConsumeParticles).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Effects).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Consumable) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.ConsumeSeconds).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Animation).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Sound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasConsumeParticles).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Effects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *SoundEvent) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.SoundEventID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FixedRange).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c SoundEvent) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.SoundEventID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.FixedRange).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *ConsumeEffect) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ConsumeEffect) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c Container) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Items).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *ContainerLoot) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c ContainerLoot) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *CreativeSlotLock) ReadFrom(r io.Reader) (int64, error) {
	return 0, nil
}

func (c CreativeSlotLock) WriteTo(w io.Writer) (int64, error) {
	return 0, nil
}

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

func (c CustomData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *CustomModelData) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Floats).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Flags).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Strings).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Colors).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CustomModelData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Floats).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Flags).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Strings).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Colors).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *CustomName) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Damage).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c *DamageResistant) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Effects).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DeathProtection) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Effects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *DebugStickState) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DebugStickState) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *DyedColor) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DyedColor) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Enchantable) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Enchantable) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

func (c Enchantments) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Enchantments).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *EntityData) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c EntityData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Equippable) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Slot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.EquipSound).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasModel).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Model).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasCameraOverlay).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CameraOverlay).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasAllowedEntities).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.AllowedEntities).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Dispensable).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Swappable).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.DamageOnHurt).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Equippable) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Slot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.EquipSound).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasModel).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Model).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasCameraOverlay).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CameraOverlay).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasAllowedEntities).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.AllowedEntities).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Dispensable).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Swappable).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.DamageOnHurt).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *FireworkExplosion) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Shape).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Colors).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.FadeColors).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasTrail).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasTwinkle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c FireworkExplosionData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Shape).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Colors).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.FadeColors).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasTrail).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasTwinkle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Fireworks) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.FlightDuration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Explosions).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Fireworks) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.FlightDuration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Explosions).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

func (c *Glider) ReadFrom(r io.Reader) (int64, error) {
	return 0, nil
}

func (c Glider) WriteTo(w io.Writer) (int64, error) {
	return 0, nil
}

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

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

func (c *Instrument) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.SoundEvent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.SoundRange).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.SoundEvent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.SoundRange).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Empty).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c IntangibleProjectile) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Empty).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *ItemModel) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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 = (*pk.Float)(&c.Duration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Output).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c JukeboxSongData) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var 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 = (*pk.Float)(&c.Duration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Output).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *LlamaVariant) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c LlamaVariant) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Lock) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Key).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Lock) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Key).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *LodestoneTracker) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.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 = (*pk.Boolean)(&c.Tracked).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c LodestoneTracker) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.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 = (*pk.Boolean)(&c.Tracked).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c Lore) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Lines).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *MapColor) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c MapColor) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c MapDecorations) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

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

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

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

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

func (c *NoteBlockSound) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Amplifier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c *PaintingVariant) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Width).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Width).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

func (c PotDecorations) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Decorations).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

func (c *PotionEffectExtraDetails) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Amplifier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Duration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Ambient).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ShowParticles).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ShowIcon).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasHiddenEffect).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PotionEffectExtraDetails) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Amplifier).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Duration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Ambient).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ShowParticles).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ShowIcon).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.HasHiddenEffect).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *PotionDurationScale) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.EffectMultiplier).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PotionDurationScale) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Float)(&c.EffectMultiplier).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Profile) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.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 = (*pk.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 = pk.Array(&c.Properties).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Profile) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.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 = (*pk.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 = pk.Array(&c.Properties).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *ProfileProperty) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Name).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.String)(&c.Value).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Name).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.String)(&c.Value).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

func (c Recipes) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *Repairable) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.SizeType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c *SheepColor) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Enchantments).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c StoredEnchantments) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Enchantments).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c SuspiciousStewEffects) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Effects).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *SuspiciousStewEffect) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.TypeID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Duration).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c SuspiciousStewEffect) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.TypeID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Duration).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *ToolRule) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.Blocks).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.Blocks).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Boolean)(&c.HideTooltip).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.HiddenComponents).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TooltipDisplay) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Boolean)(&c.HideTooltip).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.HiddenComponents).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *TooltipStyle) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Suffix).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.Suffix).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.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 *TrimPattern) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.AssetName).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (*pk.Boolean)(&c.Decal).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TrimPattern) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.AssetName).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (*pk.Boolean)(&c.Decal).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *TropicalFishBaseColor) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Pattern).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

func (c *TropicalFishPatternColor) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	return 0, nil
}

func (c Unbreakable) WriteTo(w io.Writer) (int64, error) {
	return 0, nil
}

func (c *UseCooldown) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

func (c *WolfCollar) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var 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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Variant).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

func (c WritableBookContent) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = pk.Array(&c.Pages).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *WritableBookPage) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.RawContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.RawContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.RawTitle).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (*pk.String)(&c.Author).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Generation).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Pages).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c WrittenBookContent) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.String)(&c.RawTitle).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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 = (*pk.String)(&c.Author).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Generation).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Pages).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *WrittenBookPage) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.RawContent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.RawContent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.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
}