minego/codec/packet/game/client/codecs.go

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

package client

import (
	"io"

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

func (c *AddEntity) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.ID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.UUID)(&c.UUID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.X).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.XRot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.YRot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.YHeadRot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Short)(&c.VelocityX).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Short)(&c.VelocityY).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Short)(&c.VelocityZ).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c AddEntity) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.ID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.UUID)(&c.UUID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.X).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.XRot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.YRot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.YHeadRot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Short)(&c.VelocityX).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Short)(&c.VelocityY).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Short)(&c.VelocityZ).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

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

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

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

func (c BlockDestruction) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.ID).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.UnsignedByte)(&c.Progress).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 = (&c.Position).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	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 = (&c.Position).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.NBT(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

func (c *BossEventOpAdd) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.Message).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Progress).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Color).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Overlay).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.UnsignedByte)(&c.Flags).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c BossEventOpAdd) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (&c.Message).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Progress).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Color).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.Overlay).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.UnsignedByte)(&c.Flags).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *CookieRequest) 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 CookieRequest) 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 *Cooldown) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Identifier)(&c.CooldownGroup).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 Cooldown) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Identifier)(&c.CooldownGroup).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 *CustomChatCompletions) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.Action).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Entries).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

func (c *DamageEventPos) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.X).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c DamageEventPos) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.X).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

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

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

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

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

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

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

func (c *TeleportEntity) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.EntityID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.X).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.VelocityX).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.VelocityY).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.VelocityZ).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Yaw).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Pitch).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.OnGround).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c TeleportEntity) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.EntityID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.X).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.VelocityX).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.VelocityY).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.VelocityZ).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Yaw).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.Pitch).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.OnGround).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Vec3) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.X).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Vec3) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.X).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Explode) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.CenterX).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.CenterY).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.CenterZ).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.PlayerKnockbackVelocity).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Explode) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.CenterX).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.CenterY).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.CenterZ).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.PlayerKnockbackVelocity).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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

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

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

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

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

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

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

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

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

func (c *LevelEvent) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Type).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Pos).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Int)(&c.Data).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.GlobalEvent).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c LevelEvent) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Int)(&c.Type).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.Pos).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Int)(&c.Data).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.GlobalEvent).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *CommonPlayerSpawnInfo) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.DimensionType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Identifier)(&c.Dimension).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Long)(&c.Seed).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.UnsignedByte)(&c.GameType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.PreviousGameType).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.IsDebug).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.IsFlat).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.LastDeathLocation).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.PortalCooldown).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.SeaLevel).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c CommonPlayerSpawnInfo) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.DimensionType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Identifier)(&c.Dimension).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Long)(&c.Seed).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.UnsignedByte)(&c.GameType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Byte)(&c.PreviousGameType).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.IsDebug).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.IsFlat).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.LastDeathLocation).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.PortalCooldown).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.SeaLevel).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c *Login) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.PlayerID).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Hardcore).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Levels).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.MaxPlayers).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.ChunkRadius).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.SimulationDistance).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ReducedDebugInfo).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ShowDeathScreen).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.DoLimitedCrafting).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CommonPlayerSpawnInfo).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.EnforcesSecureChat).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c Login) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.VarInt)(&c.PlayerID).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.Hardcore).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = pk.Array(&c.Levels).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.MaxPlayers).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.ChunkRadius).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.VarInt)(&c.SimulationDistance).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ReducedDebugInfo).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.ShowDeathScreen).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.DoLimitedCrafting).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (&c.CommonPlayerSpawnInfo).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Boolean)(&c.EnforcesSecureChat).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

func (c *PositionMoveRotation) ReadFrom(r io.Reader) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.X).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.YRot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.XRot).ReadFrom(r)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

func (c PositionMoveRotation) WriteTo(w io.Writer) (int64, error) {
	var n int64
	var err error
	var temp int64
	temp, err = (*pk.Double)(&c.X).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Y).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Double)(&c.Z).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.YRot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	temp, err = (*pk.Float)(&c.XRot).WriteTo(w)
	n += temp
	if err != nil {
		return n, err
	}
	return n, err
}

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

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

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

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