/*
 * Copyright (c) 2006, the libsecondlife development team
 * All rights reserved.
 *
 * - Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Neither the name of the Second Life Reverse Engineering Team nor the names
 *   of its contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

using System;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using libsecondlife;

namespace libsecondlife.Packets
{
    /// <summary>
    /// Thrown when a packet could not be successfully deserialized
    /// </summary>
    public class MalformedDataException : ApplicationException
    {
        /// <summary>
        /// Default constructor
        /// </summary>
        public MalformedDataException() { }

        /// <summary>
        /// Constructor that takes an additional error message
        /// </summary>
        /// <param name="Message">An error message to attach to this exception</param>
        public MalformedDataException(string Message)
            : base(Message)
        {
            this.Source = "Packet decoding";
        }
    }
    
    /// <summary>
    /// The Second Life header of a message template packet. Either 5, 6, or 8 
    /// bytes in length at the beginning of the packet, and encapsulates any 
    /// appended ACKs at the end of the packet as well
    /// </summary>
#if PACKETSERIALIZE
    [XmlInclude(typeof(LowHeader))]
    [XmlInclude(typeof(MediumHeader))]
    [XmlInclude(typeof(HighHeader))]
#endif
    public abstract class Header
    {
        /// <summary>Raw header data, does not include appended ACKs</summary>
        public byte[] Data;
        /// <summary>Raw value of the flags byte</summary>
        [XmlIgnore]
        public byte Flags
        {
            get { return Data[0]; }
            set { Data[0] = value; }
        }
        /// <summary>Reliable flag, whether this packet requires an ACK</summary>
        [XmlIgnore]
        public bool Reliable
        {
            get { return (Data[0] & Helpers.MSG_RELIABLE) != 0; }
            set { if (value) { Data[0] |= (byte)Helpers.MSG_RELIABLE; } else { byte mask = (byte)Helpers.MSG_RELIABLE ^ 0xFF; Data[0] &= mask; } }
        }
        /// <summary>Resent flag, whether this same packet has already been 
        /// sent</summary>
        [XmlIgnore]
        public bool Resent
        {
            get { return (Data[0] & Helpers.MSG_RESENT) != 0; }
            set { if (value) { Data[0] |= (byte)Helpers.MSG_RESENT; } else { byte mask = (byte)Helpers.MSG_RESENT ^ 0xFF; Data[0] &= mask; } }
        }
        /// <summary>Zerocoded flag, whether this packet is compressed with 
        /// zerocoding</summary>
        [XmlIgnore]
        public bool Zerocoded
        {
            get { return (Data[0] & Helpers.MSG_ZEROCODED) != 0; }
            set { if (value) { Data[0] |= (byte)Helpers.MSG_ZEROCODED; } else { byte mask = (byte)Helpers.MSG_ZEROCODED ^ 0xFF; Data[0] &= mask; } }
        }
        /// <summary>Appended ACKs flag, whether this packet has ACKs appended
        /// to the end</summary>
        [XmlIgnore]
        public bool AppendedAcks
        {
            get { return (Data[0] & Helpers.MSG_APPENDED_ACKS) != 0; }
            set { if (value) { Data[0] |= (byte)Helpers.MSG_APPENDED_ACKS; } else { byte mask = (byte)Helpers.MSG_APPENDED_ACKS ^ 0xFF; Data[0] &= mask; } }
        }
        /// <summary>Packet sequence number, three bytes long</summary>
        [XmlIgnore]
        public uint Sequence
        {
            get { return (uint)((Data[1] << 24) + (Data[2] << 16) + (Data[3] << 8) + Data[4]); }
            set {
			Data[1] = (byte)(value >> 24); Data[2] = (byte)(value >> 16); 
			Data[3] = (byte)(value >> 8);  Data[4] = (byte)(value % 256); 
		}
        }
        /// <summary>Numeric ID number of this packet</summary>
        [XmlIgnore]
        public abstract ushort ID { get; set; }
        /// <summary>Frequency classification of this packet, Low Medium or 
        /// High</summary>
        [XmlIgnore]
        public abstract PacketFrequency Frequency { get; }
        /// <summary>Convert this header to a byte array, not including any
        /// appended ACKs</summary>
        public abstract void ToBytes(byte[] bytes, ref int i);
        /// <summary>Array containing all the appended ACKs of this packet</summary>
        public uint[] AckList;

        /// <summary>
        /// Convert the AckList to a byte array, used for packet serializing
        /// </summary>
        /// <param name="bytes">Reference to the target byte array</param>
        /// <param name="i">Beginning position to start writing to in the byte
        /// array, will be updated with the ending position of the ACK list</param>
        public void AcksToBytes(byte[] bytes, ref int i)
        {
            foreach (uint ack in AckList)
            {
                bytes[i++] = (byte)((ack >> 24) % 256);
                bytes[i++] = (byte)((ack >> 16) % 256);
                bytes[i++] = (byte)((ack >> 8) % 256);
                bytes[i++] = (byte)(ack % 256);
            }
            if (AckList.Length > 0) { bytes[i++] = (byte)AckList.Length; }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="pos"></param>
        /// <param name="packetEnd"></param>
        /// <returns></returns>
        public static Header BuildHeader(byte[] bytes, ref int pos, ref int packetEnd)
        {
            if (bytes[6] == 0xFF)
            {
                if (bytes[7] == 0xFF)
                {
                    return new LowHeader(bytes, ref pos, ref packetEnd);
                }
                else
                {
                    return new MediumHeader(bytes, ref pos, ref packetEnd);
                }
            }
            else
            {
                return new HighHeader(bytes, ref pos, ref packetEnd);
            }
        }
        
        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="packetEnd"></param>
        protected void CreateAckList(byte[] bytes, ref int packetEnd)
        {
            if (AppendedAcks)
            {
                try
                {
                    int count = bytes[packetEnd--];
                    AckList = new uint[count];
                    
                    for (int i = 0; i < count; i++)
                    {
                        AckList[i] = (uint)(
                            (bytes[(packetEnd - i * 4) - 3] << 24) |
                            (bytes[(packetEnd - i * 4) - 2] << 16) |
                            (bytes[(packetEnd - i * 4) - 1] <<  8) |
                            (bytes[(packetEnd - i * 4)    ]));
                    }

                    packetEnd -= (count * 4);
                }
                catch (Exception)
                {
                    AckList = new uint[0];
                    throw new MalformedDataException();
                }
            }
            else
            {
                AckList = new uint[0];
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class LowHeader : Header
    {
        /// <summary></summary>
        public override ushort ID
        {
            get { return (ushort)((Data[8] << 8) + Data[9]); }
            set { Data[8] = (byte)(value >> 8); Data[9] = (byte)(value % 256); }
        }
        /// <summary></summary>
        public override PacketFrequency Frequency { get { return PacketFrequency.Low; } }

        /// <summary>
        /// 
        /// </summary>
        public LowHeader()
        {
            Data = new byte[10];
            Data[6] = Data[7] = 0xFF;
            AckList = new uint[0];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="pos"></param>
        /// <param name="packetEnd"></param>
        public LowHeader(byte[] bytes, ref int pos, ref int packetEnd)
        {
            if (bytes.Length < 10) { throw new MalformedDataException(); }
            Data = new byte[10];
            Buffer.BlockCopy(bytes, 0, Data, 0, 10);

            if ((bytes[0] & Helpers.MSG_ZEROCODED) != 0 && bytes[8] == 0)
            {
                if (bytes[9] == 1)
                {
                    Data[9] = bytes[10];
                }
                else
                {
                    throw new MalformedDataException();
                }
            }

            pos = 10;
            CreateAckList(bytes, ref packetEnd);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="i"></param>
        public override void ToBytes(byte[] bytes, ref int i)
        {
            Buffer.BlockCopy(Data, 0, bytes, i, 10);
            i += 10;
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class MediumHeader : Header
    {
        /// <summary></summary>
        public override ushort ID
        {
            get { return (ushort)Data[7]; }
            set { Data[7] = (byte)value; }
        }
        /// <summary></summary>
        public override PacketFrequency Frequency { get { return PacketFrequency.Medium; } }

        /// <summary>
        /// 
        /// </summary>
        public MediumHeader()
        {
            Data = new byte[8];
            Data[6] = 0xFF;
            AckList = new uint[0];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="pos"></param>
        /// <param name="packetEnd"></param>
        public MediumHeader(byte[] bytes, ref int pos, ref int packetEnd)
        {
            if (bytes.Length < 8) { throw new MalformedDataException(); }
            Data = new byte[8];
            Buffer.BlockCopy(bytes, 0, Data, 0, 8);
            pos = 8;
            CreateAckList(bytes, ref packetEnd);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="i"></param>
        public override void ToBytes(byte[] bytes, ref int i)
        {
            Buffer.BlockCopy(Data, 0, bytes, i, 8);
            i += 8;
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class HighHeader : Header
    {
        /// <summary></summary>
        public override ushort ID
        {
            get { return (ushort)Data[6]; }
            set { Data[6] = (byte)value; }
        }
        /// <summary></summary>
        public override PacketFrequency Frequency { get { return PacketFrequency.High; } }

        /// <summary>
        /// 
        /// </summary>
        public HighHeader()
        {
            Data = new byte[7];
            AckList = new uint[0];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="pos"></param>
        /// <param name="packetEnd"></param>
        public HighHeader(byte[] bytes, ref int pos, ref int packetEnd)
        {
            if (bytes.Length < 7) { throw new MalformedDataException(); }
            Data = new byte[7];
            Buffer.BlockCopy(bytes, 0, Data, 0, 7);
            pos = 7;
            CreateAckList(bytes, ref packetEnd);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="i"></param>
        public override void ToBytes(byte[] bytes, ref int i)
        {
            Buffer.BlockCopy(Data, 0, bytes, i, 7);
            i += 7;
        }
    }

    public enum PacketType
    {
        /// <summary>A generic value, not an actual packet type</summary>
        Default,
        TestMessage = 65537,
        UseCircuitCode = 65539,
        TelehubInfo = 65546,
        EconomyDataRequest = 65560,
        EconomyData = 65561,
        AvatarPickerRequest = 65562,
        AvatarPickerReply = 65564,
        PlacesQuery = 65565,
        PlacesReply = 65566,
        DirFindQuery = 65567,
        DirPlacesQuery = 65569,
        DirPlacesReply = 65571,
        DirPeopleReply = 65572,
        DirEventsReply = 65573,
        DirGroupsReply = 65574,
        DirClassifiedQuery = 65575,
        DirClassifiedReply = 65577,
        AvatarClassifiedReply = 65578,
        ClassifiedInfoRequest = 65579,
        ClassifiedInfoReply = 65580,
        ClassifiedInfoUpdate = 65581,
        ClassifiedDelete = 65582,
        ClassifiedGodDelete = 65583,
        DirLandQuery = 65584,
        DirLandReply = 65586,
        DirPopularQuery = 65587,
        DirPopularReply = 65589,
        ParcelInfoRequest = 65590,
        ParcelInfoReply = 65591,
        ParcelObjectOwnersRequest = 65592,
        ParcelObjectOwnersReply = 65593,
        GroupNoticesListRequest = 65594,
        GroupNoticesListReply = 65595,
        GroupNoticeRequest = 65596,
        TeleportRequest = 65598,
        TeleportLocationRequest = 65599,
        TeleportLocal = 65600,
        TeleportLandmarkRequest = 65601,
        TeleportProgress = 65602,
        TeleportFinish = 65605,
        StartLure = 65606,
        TeleportLureRequest = 65607,
        TeleportCancel = 65608,
        TeleportStart = 65609,
        TeleportFailed = 65610,
        Undo = 65611,
        Redo = 65612,
        UndoLand = 65613,
        AgentPause = 65614,
        AgentResume = 65615,
        ChatFromViewer = 65616,
        AgentThrottle = 65617,
        AgentFOV = 65618,
        AgentHeightWidth = 65619,
        AgentSetAppearance = 65620,
        AgentQuitCopy = 65621,
        ImageNotInDatabase = 65622,
        RebakeAvatarTextures = 65623,
        SetAlwaysRun = 65624,
        ObjectDelete = 65625,
        ObjectDuplicate = 65626,
        ObjectDuplicateOnRay = 65627,
        ObjectScale = 65628,
        ObjectRotation = 65629,
        ObjectFlagUpdate = 65630,
        ObjectClickAction = 65631,
        ObjectImage = 65632,
        ObjectMaterial = 65633,
        ObjectShape = 65634,
        ObjectExtraParams = 65635,
        ObjectOwner = 65636,
        ObjectGroup = 65637,
        ObjectBuy = 65638,
        BuyObjectInventory = 65639,
        DerezContainer = 65640,
        ObjectPermissions = 65641,
        ObjectSaleInfo = 65642,
        ObjectName = 65643,
        ObjectDescription = 65644,
        ObjectCategory = 65645,
        ObjectSelect = 65646,
        ObjectDeselect = 65647,
        ObjectAttach = 65648,
        ObjectDetach = 65649,
        ObjectDrop = 65650,
        ObjectLink = 65651,
        ObjectDelink = 65652,
        ObjectGrab = 65653,
        ObjectGrabUpdate = 65654,
        ObjectDeGrab = 65655,
        ObjectSpinStart = 65656,
        ObjectSpinUpdate = 65657,
        ObjectSpinStop = 65658,
        ObjectExportSelected = 65659,
        ModifyLand = 65660,
        VelocityInterpolateOn = 65661,
        VelocityInterpolateOff = 65662,
        StateSave = 65663,
        ReportAutosaveCrash = 65664,
        SimWideDeletes = 65665,
        TrackAgent = 65666,
        ViewerStats = 65667,
        ScriptAnswerYes = 65668,
        UserReport = 65669,
        AlertMessage = 65670,
        AgentAlertMessage = 65671,
        MeanCollisionAlert = 65672,
        ViewerFrozenMessage = 65673,
        HealthMessage = 65674,
        ChatFromSimulator = 65675,
        SimStats = 65676,
        RequestRegionInfo = 65677,
        RegionInfo = 65678,
        GodUpdateRegionInfo = 65679,
        NearestLandingRegionUpdated = 65682,
        RegionHandshake = 65684,
        RegionHandshakeReply = 65685,
        SimulatorViewerTimeMessage = 65686,
        EnableSimulator = 65687,
        DisableSimulator = 65688,
        TransferRequest = 65689,
        TransferInfo = 65690,
        TransferAbort = 65691,
        RequestXfer = 65692,
        AbortXfer = 65693,
        AvatarAppearance = 65694,
        SetFollowCamProperties = 65695,
        ClearFollowCamProperties = 65696,
        RequestPayPrice = 65697,
        PayPriceReply = 65698,
        KickUser = 65699,
        KickUserAck = 65700,
        GodKickUser = 65701,
        EjectUser = 65703,
        FreezeUser = 65704,
        AvatarPropertiesRequest = 65705,
        AvatarPropertiesReply = 65707,
        AvatarInterestsReply = 65708,
        AvatarGroupsReply = 65709,
        AvatarPropertiesUpdate = 65710,
        AvatarInterestsUpdate = 65711,
        AvatarNotesReply = 65712,
        AvatarNotesUpdate = 65713,
        AvatarPicksReply = 65714,
        EventInfoRequest = 65715,
        EventInfoReply = 65716,
        EventNotificationAddRequest = 65717,
        EventNotificationRemoveRequest = 65718,
        EventGodDelete = 65719,
        PickInfoReply = 65720,
        PickInfoUpdate = 65721,
        PickDelete = 65722,
        PickGodDelete = 65723,
        ScriptQuestion = 65724,
        ScriptControlChange = 65725,
        ScriptDialog = 65726,
        ScriptDialogReply = 65727,
        ForceScriptControlRelease = 65728,
        RevokePermissions = 65729,
        LoadURL = 65730,
        ScriptTeleportRequest = 65731,
        ParcelOverlay = 65732,
        ParcelPropertiesRequestByID = 65733,
        ParcelPropertiesUpdate = 65734,
        ParcelReturnObjects = 65735,
        ParcelSetOtherCleanTime = 65736,
        ParcelDisableObjects = 65737,
        ParcelSelectObjects = 65738,
        EstateCovenantRequest = 65739,
        EstateCovenantReply = 65740,
        ForceObjectSelect = 65741,
        ParcelBuyPass = 65742,
        ParcelDeedToGroup = 65743,
        ParcelReclaim = 65744,
        ParcelClaim = 65745,
        ParcelJoin = 65746,
        ParcelDivide = 65747,
        ParcelRelease = 65748,
        ParcelBuy = 65749,
        ParcelGodForceOwner = 65750,
        ParcelAccessListRequest = 65751,
        ParcelAccessListReply = 65752,
        ParcelAccessListUpdate = 65753,
        ParcelDwellRequest = 65754,
        ParcelDwellReply = 65755,
        ParcelGodMarkAsContent = 65763,
        ViewerStartAuction = 65764,
        UUIDNameRequest = 65771,
        UUIDNameReply = 65772,
        UUIDGroupNameRequest = 65773,
        UUIDGroupNameReply = 65774,
        ChildAgentDying = 65776,
        ChildAgentUnknown = 65777,
        GetScriptRunning = 65779,
        ScriptRunningReply = 65780,
        SetScriptRunning = 65781,
        ScriptReset = 65782,
        ScriptSensorRequest = 65783,
        ScriptSensorReply = 65784,
        CompleteAgentMovement = 65785,
        AgentMovementComplete = 65786,
        LogoutRequest = 65788,
        LogoutReply = 65789,
        ImprovedInstantMessage = 65790,
        RetrieveInstantMessages = 65791,
        FindAgent = 65792,
        RequestGodlikePowers = 65793,
        GrantGodlikePowers = 65794,
        GodlikeMessage = 65795,
        EstateOwnerMessage = 65796,
        GenericMessage = 65797,
        MuteListRequest = 65798,
        UpdateMuteListEntry = 65799,
        RemoveMuteListEntry = 65800,
        CopyInventoryFromNotecard = 65801,
        UpdateInventoryItem = 65802,
        UpdateCreateInventoryItem = 65803,
        MoveInventoryItem = 65804,
        CopyInventoryItem = 65805,
        RemoveInventoryItem = 65806,
        ChangeInventoryItemFlags = 65807,
        SaveAssetIntoInventory = 65808,
        CreateInventoryFolder = 65809,
        UpdateInventoryFolder = 65810,
        MoveInventoryFolder = 65811,
        RemoveInventoryFolder = 65812,
        FetchInventoryDescendents = 65813,
        InventoryDescendents = 65814,
        FetchInventory = 65815,
        FetchInventoryReply = 65816,
        BulkUpdateInventory = 65817,
        RequestInventoryAsset = 65818,
        InventoryAssetResponse = 65819,
        RemoveInventoryObjects = 65820,
        PurgeInventoryDescendents = 65821,
        UpdateTaskInventory = 65822,
        RemoveTaskInventory = 65823,
        MoveTaskInventory = 65824,
        RequestTaskInventory = 65825,
        ReplyTaskInventory = 65826,
        DeRezObject = 65827,
        DeRezAck = 65828,
        RezObject = 65829,
        RezObjectFromNotecard = 65830,
        AcceptFriendship = 65833,
        DeclineFriendship = 65834,
        FormFriendship = 65835,
        TerminateFriendship = 65836,
        OfferCallingCard = 65837,
        AcceptCallingCard = 65838,
        DeclineCallingCard = 65839,
        RezScript = 65840,
        CreateInventoryItem = 65841,
        CreateLandmarkForEvent = 65842,
        RegionHandleRequest = 65845,
        RegionIDAndHandleReply = 65846,
        MoneyTransferRequest = 65847,
        MoneyBalanceRequest = 65849,
        MoneyBalanceReply = 65850,
        RoutedMoneyBalanceReply = 65851,
        ActivateGestures = 65852,
        DeactivateGestures = 65853,
        MuteListUpdate = 65854,
        UseCachedMuteList = 65855,
        GrantUserRights = 65856,
        ChangeUserRights = 65857,
        OnlineNotification = 65858,
        OfflineNotification = 65859,
        SetStartLocationRequest = 65860,
        AssetUploadRequest = 65869,
        AssetUploadComplete = 65870,
        CreateGroupRequest = 65875,
        CreateGroupReply = 65876,
        UpdateGroupInfo = 65877,
        GroupRoleChanges = 65878,
        JoinGroupRequest = 65879,
        JoinGroupReply = 65880,
        EjectGroupMemberRequest = 65881,
        EjectGroupMemberReply = 65882,
        LeaveGroupRequest = 65883,
        LeaveGroupReply = 65884,
        InviteGroupRequest = 65885,
        GroupProfileRequest = 65887,
        GroupProfileReply = 65888,
        GroupAccountSummaryRequest = 65889,
        GroupAccountSummaryReply = 65890,
        GroupAccountDetailsRequest = 65891,
        GroupAccountDetailsReply = 65892,
        GroupAccountTransactionsRequest = 65893,
        GroupAccountTransactionsReply = 65894,
        GroupActiveProposalsRequest = 65895,
        GroupActiveProposalItemReply = 65896,
        GroupVoteHistoryRequest = 65897,
        GroupVoteHistoryItemReply = 65898,
        StartGroupProposal = 65899,
        GroupProposalBallot = 65900,
        GroupMembersRequest = 65902,
        GroupMembersReply = 65903,
        ActivateGroup = 65904,
        SetGroupContribution = 65905,
        SetGroupAcceptNotices = 65906,
        GroupRoleDataRequest = 65907,
        GroupRoleDataReply = 65908,
        GroupRoleMembersRequest = 65909,
        GroupRoleMembersReply = 65910,
        GroupTitlesRequest = 65911,
        GroupTitlesReply = 65912,
        GroupTitleUpdate = 65913,
        GroupRoleUpdate = 65914,
        LiveHelpGroupRequest = 65915,
        LiveHelpGroupReply = 65916,
        AgentWearablesRequest = 65917,
        AgentWearablesUpdate = 65918,
        AgentIsNowWearing = 65919,
        AgentCachedTexture = 65920,
        AgentCachedTextureResponse = 65921,
        AgentDataUpdateRequest = 65922,
        AgentDataUpdate = 65923,
        GroupDataUpdate = 65924,
        AgentGroupDataUpdate = 65925,
        AgentDropGroup = 65926,
        CreateTrustedCircuit = 65928,
        DenyTrustedCircuit = 65929,
        RequestTrustedCircuit = 65930,
        RezSingleAttachmentFromInv = 65931,
        RezMultipleAttachmentsFromInv = 65932,
        DetachAttachmentIntoInv = 65933,
        CreateNewOutfitAttachments = 65934,
        UserInfoRequest = 65935,
        UserInfoReply = 65936,
        UpdateUserInfo = 65937,
        InitiateDownload = 65939,
        SystemMessage = 65940,
        MapLayerRequest = 65941,
        MapLayerReply = 65942,
        MapBlockRequest = 65943,
        MapNameRequest = 65944,
        MapBlockReply = 65945,
        MapItemRequest = 65946,
        MapItemReply = 65947,
        SendPostcard = 65948,
        ParcelMediaCommandMessage = 65955,
        ParcelMediaUpdate = 65956,
        LandStatRequest = 65957,
        LandStatReply = 65958,
        Error = 65959,
        PacketAck = 131067,
        OpenCircuit = 131068,
        CloseCircuit = 131069,
        ObjectAdd = 131073,
        MultipleObjectUpdate = 131074,
        RequestMultipleObjects = 131075,
        ObjectPosition = 131076,
        RequestObjectPropertiesFamily = 131077,
        CoarseLocationUpdate = 131078,
        CrossedRegion = 131079,
        ConfirmEnableSimulator = 131080,
        ObjectProperties = 131081,
        ObjectPropertiesFamily = 131082,
        ParcelPropertiesRequest = 131083,
        AttachedSound = 131085,
        AttachedSoundGainChange = 131086,
        PreloadSound = 131087,
        ViewerEffect = 131089,
        StartPingCheck = 196609,
        CompletePingCheck = 196610,
        AgentUpdate = 196612,
        AgentAnimation = 196613,
        AgentRequestSit = 196614,
        AgentSit = 196615,
        RequestImage = 196616,
        ImageData = 196617,
        ImagePacket = 196618,
        LayerData = 196619,
        ObjectUpdate = 196620,
        ObjectUpdateCompressed = 196621,
        ObjectUpdateCached = 196622,
        ImprovedTerseObjectUpdate = 196623,
        KillObject = 196624,
        TransferPacket = 196625,
        SendXferPacket = 196626,
        ConfirmXferPacket = 196627,
        AvatarAnimation = 196628,
        AvatarSitResponse = 196629,
        CameraConstraint = 196630,
        ParcelProperties = 196631,
        ChildAgentUpdate = 196633,
        ChildAgentAlive = 196634,
        ChildAgentPositionUpdate = 196635,
        SoundTrigger = 196637,
    }

#if PACKETSERIALIZE
    [XmlInclude(typeof(TestMessagePacket))]
    [XmlInclude(typeof(UseCircuitCodePacket))]
    [XmlInclude(typeof(TelehubInfoPacket))]
    [XmlInclude(typeof(EconomyDataRequestPacket))]
    [XmlInclude(typeof(EconomyDataPacket))]
    [XmlInclude(typeof(AvatarPickerRequestPacket))]
    [XmlInclude(typeof(AvatarPickerReplyPacket))]
    [XmlInclude(typeof(PlacesQueryPacket))]
    [XmlInclude(typeof(PlacesReplyPacket))]
    [XmlInclude(typeof(DirFindQueryPacket))]
    [XmlInclude(typeof(DirPlacesQueryPacket))]
    [XmlInclude(typeof(DirPlacesReplyPacket))]
    [XmlInclude(typeof(DirPeopleReplyPacket))]
    [XmlInclude(typeof(DirEventsReplyPacket))]
    [XmlInclude(typeof(DirGroupsReplyPacket))]
    [XmlInclude(typeof(DirClassifiedQueryPacket))]
    [XmlInclude(typeof(DirClassifiedReplyPacket))]
    [XmlInclude(typeof(AvatarClassifiedReplyPacket))]
    [XmlInclude(typeof(ClassifiedInfoRequestPacket))]
    [XmlInclude(typeof(ClassifiedInfoReplyPacket))]
    [XmlInclude(typeof(ClassifiedInfoUpdatePacket))]
    [XmlInclude(typeof(ClassifiedDeletePacket))]
    [XmlInclude(typeof(ClassifiedGodDeletePacket))]
    [XmlInclude(typeof(DirLandQueryPacket))]
    [XmlInclude(typeof(DirLandReplyPacket))]
    [XmlInclude(typeof(DirPopularQueryPacket))]
    [XmlInclude(typeof(DirPopularReplyPacket))]
    [XmlInclude(typeof(ParcelInfoRequestPacket))]
    [XmlInclude(typeof(ParcelInfoReplyPacket))]
    [XmlInclude(typeof(ParcelObjectOwnersRequestPacket))]
    [XmlInclude(typeof(ParcelObjectOwnersReplyPacket))]
    [XmlInclude(typeof(GroupNoticesListRequestPacket))]
    [XmlInclude(typeof(GroupNoticesListReplyPacket))]
    [XmlInclude(typeof(GroupNoticeRequestPacket))]
    [XmlInclude(typeof(TeleportRequestPacket))]
    [XmlInclude(typeof(TeleportLocationRequestPacket))]
    [XmlInclude(typeof(TeleportLocalPacket))]
    [XmlInclude(typeof(TeleportLandmarkRequestPacket))]
    [XmlInclude(typeof(TeleportProgressPacket))]
    [XmlInclude(typeof(TeleportFinishPacket))]
    [XmlInclude(typeof(StartLurePacket))]
    [XmlInclude(typeof(TeleportLureRequestPacket))]
    [XmlInclude(typeof(TeleportCancelPacket))]
    [XmlInclude(typeof(TeleportStartPacket))]
    [XmlInclude(typeof(TeleportFailedPacket))]
    [XmlInclude(typeof(UndoPacket))]
    [XmlInclude(typeof(RedoPacket))]
    [XmlInclude(typeof(UndoLandPacket))]
    [XmlInclude(typeof(AgentPausePacket))]
    [XmlInclude(typeof(AgentResumePacket))]
    [XmlInclude(typeof(ChatFromViewerPacket))]
    [XmlInclude(typeof(AgentThrottlePacket))]
    [XmlInclude(typeof(AgentFOVPacket))]
    [XmlInclude(typeof(AgentHeightWidthPacket))]
    [XmlInclude(typeof(AgentSetAppearancePacket))]
    [XmlInclude(typeof(AgentQuitCopyPacket))]
    [XmlInclude(typeof(ImageNotInDatabasePacket))]
    [XmlInclude(typeof(RebakeAvatarTexturesPacket))]
    [XmlInclude(typeof(SetAlwaysRunPacket))]
    [XmlInclude(typeof(ObjectDeletePacket))]
    [XmlInclude(typeof(ObjectDuplicatePacket))]
    [XmlInclude(typeof(ObjectDuplicateOnRayPacket))]
    [XmlInclude(typeof(ObjectScalePacket))]
    [XmlInclude(typeof(ObjectRotationPacket))]
    [XmlInclude(typeof(ObjectFlagUpdatePacket))]
    [XmlInclude(typeof(ObjectClickActionPacket))]
    [XmlInclude(typeof(ObjectImagePacket))]
    [XmlInclude(typeof(ObjectMaterialPacket))]
    [XmlInclude(typeof(ObjectShapePacket))]
    [XmlInclude(typeof(ObjectExtraParamsPacket))]
    [XmlInclude(typeof(ObjectOwnerPacket))]
    [XmlInclude(typeof(ObjectGroupPacket))]
    [XmlInclude(typeof(ObjectBuyPacket))]
    [XmlInclude(typeof(BuyObjectInventoryPacket))]
    [XmlInclude(typeof(DerezContainerPacket))]
    [XmlInclude(typeof(ObjectPermissionsPacket))]
    [XmlInclude(typeof(ObjectSaleInfoPacket))]
    [XmlInclude(typeof(ObjectNamePacket))]
    [XmlInclude(typeof(ObjectDescriptionPacket))]
    [XmlInclude(typeof(ObjectCategoryPacket))]
    [XmlInclude(typeof(ObjectSelectPacket))]
    [XmlInclude(typeof(ObjectDeselectPacket))]
    [XmlInclude(typeof(ObjectAttachPacket))]
    [XmlInclude(typeof(ObjectDetachPacket))]
    [XmlInclude(typeof(ObjectDropPacket))]
    [XmlInclude(typeof(ObjectLinkPacket))]
    [XmlInclude(typeof(ObjectDelinkPacket))]
    [XmlInclude(typeof(ObjectGrabPacket))]
    [XmlInclude(typeof(ObjectGrabUpdatePacket))]
    [XmlInclude(typeof(ObjectDeGrabPacket))]
    [XmlInclude(typeof(ObjectSpinStartPacket))]
    [XmlInclude(typeof(ObjectSpinUpdatePacket))]
    [XmlInclude(typeof(ObjectSpinStopPacket))]
    [XmlInclude(typeof(ObjectExportSelectedPacket))]
    [XmlInclude(typeof(ModifyLandPacket))]
    [XmlInclude(typeof(VelocityInterpolateOnPacket))]
    [XmlInclude(typeof(VelocityInterpolateOffPacket))]
    [XmlInclude(typeof(StateSavePacket))]
    [XmlInclude(typeof(ReportAutosaveCrashPacket))]
    [XmlInclude(typeof(SimWideDeletesPacket))]
    [XmlInclude(typeof(TrackAgentPacket))]
    [XmlInclude(typeof(ViewerStatsPacket))]
    [XmlInclude(typeof(ScriptAnswerYesPacket))]
    [XmlInclude(typeof(UserReportPacket))]
    [XmlInclude(typeof(AlertMessagePacket))]
    [XmlInclude(typeof(AgentAlertMessagePacket))]
    [XmlInclude(typeof(MeanCollisionAlertPacket))]
    [XmlInclude(typeof(ViewerFrozenMessagePacket))]
    [XmlInclude(typeof(HealthMessagePacket))]
    [XmlInclude(typeof(ChatFromSimulatorPacket))]
    [XmlInclude(typeof(SimStatsPacket))]
    [XmlInclude(typeof(RequestRegionInfoPacket))]
    [XmlInclude(typeof(RegionInfoPacket))]
    [XmlInclude(typeof(GodUpdateRegionInfoPacket))]
    [XmlInclude(typeof(NearestLandingRegionUpdatedPacket))]
    [XmlInclude(typeof(RegionHandshakePacket))]
    [XmlInclude(typeof(RegionHandshakeReplyPacket))]
    [XmlInclude(typeof(SimulatorViewerTimeMessagePacket))]
    [XmlInclude(typeof(EnableSimulatorPacket))]
    [XmlInclude(typeof(DisableSimulatorPacket))]
    [XmlInclude(typeof(TransferRequestPacket))]
    [XmlInclude(typeof(TransferInfoPacket))]
    [XmlInclude(typeof(TransferAbortPacket))]
    [XmlInclude(typeof(RequestXferPacket))]
    [XmlInclude(typeof(AbortXferPacket))]
    [XmlInclude(typeof(AvatarAppearancePacket))]
    [XmlInclude(typeof(SetFollowCamPropertiesPacket))]
    [XmlInclude(typeof(ClearFollowCamPropertiesPacket))]
    [XmlInclude(typeof(RequestPayPricePacket))]
    [XmlInclude(typeof(PayPriceReplyPacket))]
    [XmlInclude(typeof(KickUserPacket))]
    [XmlInclude(typeof(KickUserAckPacket))]
    [XmlInclude(typeof(GodKickUserPacket))]
    [XmlInclude(typeof(EjectUserPacket))]
    [XmlInclude(typeof(FreezeUserPacket))]
    [XmlInclude(typeof(AvatarPropertiesRequestPacket))]
    [XmlInclude(typeof(AvatarPropertiesReplyPacket))]
    [XmlInclude(typeof(AvatarInterestsReplyPacket))]
    [XmlInclude(typeof(AvatarGroupsReplyPacket))]
    [XmlInclude(typeof(AvatarPropertiesUpdatePacket))]
    [XmlInclude(typeof(AvatarInterestsUpdatePacket))]
    [XmlInclude(typeof(AvatarNotesReplyPacket))]
    [XmlInclude(typeof(AvatarNotesUpdatePacket))]
    [XmlInclude(typeof(AvatarPicksReplyPacket))]
    [XmlInclude(typeof(EventInfoRequestPacket))]
    [XmlInclude(typeof(EventInfoReplyPacket))]
    [XmlInclude(typeof(EventNotificationAddRequestPacket))]
    [XmlInclude(typeof(EventNotificationRemoveRequestPacket))]
    [XmlInclude(typeof(EventGodDeletePacket))]
    [XmlInclude(typeof(PickInfoReplyPacket))]
    [XmlInclude(typeof(PickInfoUpdatePacket))]
    [XmlInclude(typeof(PickDeletePacket))]
    [XmlInclude(typeof(PickGodDeletePacket))]
    [XmlInclude(typeof(ScriptQuestionPacket))]
    [XmlInclude(typeof(ScriptControlChangePacket))]
    [XmlInclude(typeof(ScriptDialogPacket))]
    [XmlInclude(typeof(ScriptDialogReplyPacket))]
    [XmlInclude(typeof(ForceScriptControlReleasePacket))]
    [XmlInclude(typeof(RevokePermissionsPacket))]
    [XmlInclude(typeof(LoadURLPacket))]
    [XmlInclude(typeof(ScriptTeleportRequestPacket))]
    [XmlInclude(typeof(ParcelOverlayPacket))]
    [XmlInclude(typeof(ParcelPropertiesRequestByIDPacket))]
    [XmlInclude(typeof(ParcelPropertiesUpdatePacket))]
    [XmlInclude(typeof(ParcelReturnObjectsPacket))]
    [XmlInclude(typeof(ParcelSetOtherCleanTimePacket))]
    [XmlInclude(typeof(ParcelDisableObjectsPacket))]
    [XmlInclude(typeof(ParcelSelectObjectsPacket))]
    [XmlInclude(typeof(EstateCovenantRequestPacket))]
    [XmlInclude(typeof(EstateCovenantReplyPacket))]
    [XmlInclude(typeof(ForceObjectSelectPacket))]
    [XmlInclude(typeof(ParcelBuyPassPacket))]
    [XmlInclude(typeof(ParcelDeedToGroupPacket))]
    [XmlInclude(typeof(ParcelReclaimPacket))]
    [XmlInclude(typeof(ParcelClaimPacket))]
    [XmlInclude(typeof(ParcelJoinPacket))]
    [XmlInclude(typeof(ParcelDividePacket))]
    [XmlInclude(typeof(ParcelReleasePacket))]
    [XmlInclude(typeof(ParcelBuyPacket))]
    [XmlInclude(typeof(ParcelGodForceOwnerPacket))]
    [XmlInclude(typeof(ParcelAccessListRequestPacket))]
    [XmlInclude(typeof(ParcelAccessListReplyPacket))]
    [XmlInclude(typeof(ParcelAccessListUpdatePacket))]
    [XmlInclude(typeof(ParcelDwellRequestPacket))]
    [XmlInclude(typeof(ParcelDwellReplyPacket))]
    [XmlInclude(typeof(ParcelGodMarkAsContentPacket))]
    [XmlInclude(typeof(ViewerStartAuctionPacket))]
    [XmlInclude(typeof(UUIDNameRequestPacket))]
    [XmlInclude(typeof(UUIDNameReplyPacket))]
    [XmlInclude(typeof(UUIDGroupNameRequestPacket))]
    [XmlInclude(typeof(UUIDGroupNameReplyPacket))]
    [XmlInclude(typeof(ChildAgentDyingPacket))]
    [XmlInclude(typeof(ChildAgentUnknownPacket))]
    [XmlInclude(typeof(GetScriptRunningPacket))]
    [XmlInclude(typeof(ScriptRunningReplyPacket))]
    [XmlInclude(typeof(SetScriptRunningPacket))]
    [XmlInclude(typeof(ScriptResetPacket))]
    [XmlInclude(typeof(ScriptSensorRequestPacket))]
    [XmlInclude(typeof(ScriptSensorReplyPacket))]
    [XmlInclude(typeof(CompleteAgentMovementPacket))]
    [XmlInclude(typeof(AgentMovementCompletePacket))]
    [XmlInclude(typeof(LogoutRequestPacket))]
    [XmlInclude(typeof(LogoutReplyPacket))]
    [XmlInclude(typeof(ImprovedInstantMessagePacket))]
    [XmlInclude(typeof(RetrieveInstantMessagesPacket))]
    [XmlInclude(typeof(FindAgentPacket))]
    [XmlInclude(typeof(RequestGodlikePowersPacket))]
    [XmlInclude(typeof(GrantGodlikePowersPacket))]
    [XmlInclude(typeof(GodlikeMessagePacket))]
    [XmlInclude(typeof(EstateOwnerMessagePacket))]
    [XmlInclude(typeof(GenericMessagePacket))]
    [XmlInclude(typeof(MuteListRequestPacket))]
    [XmlInclude(typeof(UpdateMuteListEntryPacket))]
    [XmlInclude(typeof(RemoveMuteListEntryPacket))]
    [XmlInclude(typeof(CopyInventoryFromNotecardPacket))]
    [XmlInclude(typeof(UpdateInventoryItemPacket))]
    [XmlInclude(typeof(UpdateCreateInventoryItemPacket))]
    [XmlInclude(typeof(MoveInventoryItemPacket))]
    [XmlInclude(typeof(CopyInventoryItemPacket))]
    [XmlInclude(typeof(RemoveInventoryItemPacket))]
    [XmlInclude(typeof(ChangeInventoryItemFlagsPacket))]
    [XmlInclude(typeof(SaveAssetIntoInventoryPacket))]
    [XmlInclude(typeof(CreateInventoryFolderPacket))]
    [XmlInclude(typeof(UpdateInventoryFolderPacket))]
    [XmlInclude(typeof(MoveInventoryFolderPacket))]
    [XmlInclude(typeof(RemoveInventoryFolderPacket))]
    [XmlInclude(typeof(FetchInventoryDescendentsPacket))]
    [XmlInclude(typeof(InventoryDescendentsPacket))]
    [XmlInclude(typeof(FetchInventoryPacket))]
    [XmlInclude(typeof(FetchInventoryReplyPacket))]
    [XmlInclude(typeof(BulkUpdateInventoryPacket))]
    [XmlInclude(typeof(RequestInventoryAssetPacket))]
    [XmlInclude(typeof(InventoryAssetResponsePacket))]
    [XmlInclude(typeof(RemoveInventoryObjectsPacket))]
    [XmlInclude(typeof(PurgeInventoryDescendentsPacket))]
    [XmlInclude(typeof(UpdateTaskInventoryPacket))]
    [XmlInclude(typeof(RemoveTaskInventoryPacket))]
    [XmlInclude(typeof(MoveTaskInventoryPacket))]
    [XmlInclude(typeof(RequestTaskInventoryPacket))]
    [XmlInclude(typeof(ReplyTaskInventoryPacket))]
    [XmlInclude(typeof(DeRezObjectPacket))]
    [XmlInclude(typeof(DeRezAckPacket))]
    [XmlInclude(typeof(RezObjectPacket))]
    [XmlInclude(typeof(RezObjectFromNotecardPacket))]
    [XmlInclude(typeof(AcceptFriendshipPacket))]
    [XmlInclude(typeof(DeclineFriendshipPacket))]
    [XmlInclude(typeof(FormFriendshipPacket))]
    [XmlInclude(typeof(TerminateFriendshipPacket))]
    [XmlInclude(typeof(OfferCallingCardPacket))]
    [XmlInclude(typeof(AcceptCallingCardPacket))]
    [XmlInclude(typeof(DeclineCallingCardPacket))]
    [XmlInclude(typeof(RezScriptPacket))]
    [XmlInclude(typeof(CreateInventoryItemPacket))]
    [XmlInclude(typeof(CreateLandmarkForEventPacket))]
    [XmlInclude(typeof(RegionHandleRequestPacket))]
    [XmlInclude(typeof(RegionIDAndHandleReplyPacket))]
    [XmlInclude(typeof(MoneyTransferRequestPacket))]
    [XmlInclude(typeof(MoneyBalanceRequestPacket))]
    [XmlInclude(typeof(MoneyBalanceReplyPacket))]
    [XmlInclude(typeof(RoutedMoneyBalanceReplyPacket))]
    [XmlInclude(typeof(ActivateGesturesPacket))]
    [XmlInclude(typeof(DeactivateGesturesPacket))]
    [XmlInclude(typeof(MuteListUpdatePacket))]
    [XmlInclude(typeof(UseCachedMuteListPacket))]
    [XmlInclude(typeof(GrantUserRightsPacket))]
    [XmlInclude(typeof(ChangeUserRightsPacket))]
    [XmlInclude(typeof(OnlineNotificationPacket))]
    [XmlInclude(typeof(OfflineNotificationPacket))]
    [XmlInclude(typeof(SetStartLocationRequestPacket))]
    [XmlInclude(typeof(AssetUploadRequestPacket))]
    [XmlInclude(typeof(AssetUploadCompletePacket))]
    [XmlInclude(typeof(CreateGroupRequestPacket))]
    [XmlInclude(typeof(CreateGroupReplyPacket))]
    [XmlInclude(typeof(UpdateGroupInfoPacket))]
    [XmlInclude(typeof(GroupRoleChangesPacket))]
    [XmlInclude(typeof(JoinGroupRequestPacket))]
    [XmlInclude(typeof(JoinGroupReplyPacket))]
    [XmlInclude(typeof(EjectGroupMemberRequestPacket))]
    [XmlInclude(typeof(EjectGroupMemberReplyPacket))]
    [XmlInclude(typeof(LeaveGroupRequestPacket))]
    [XmlInclude(typeof(LeaveGroupReplyPacket))]
    [XmlInclude(typeof(InviteGroupRequestPacket))]
    [XmlInclude(typeof(GroupProfileRequestPacket))]
    [XmlInclude(typeof(GroupProfileReplyPacket))]
    [XmlInclude(typeof(GroupAccountSummaryRequestPacket))]
    [XmlInclude(typeof(GroupAccountSummaryReplyPacket))]
    [XmlInclude(typeof(GroupAccountDetailsRequestPacket))]
    [XmlInclude(typeof(GroupAccountDetailsReplyPacket))]
    [XmlInclude(typeof(GroupAccountTransactionsRequestPacket))]
    [XmlInclude(typeof(GroupAccountTransactionsReplyPacket))]
    [XmlInclude(typeof(GroupActiveProposalsRequestPacket))]
    [XmlInclude(typeof(GroupActiveProposalItemReplyPacket))]
    [XmlInclude(typeof(GroupVoteHistoryRequestPacket))]
    [XmlInclude(typeof(GroupVoteHistoryItemReplyPacket))]
    [XmlInclude(typeof(StartGroupProposalPacket))]
    [XmlInclude(typeof(GroupProposalBallotPacket))]
    [XmlInclude(typeof(GroupMembersRequestPacket))]
    [XmlInclude(typeof(GroupMembersReplyPacket))]
    [XmlInclude(typeof(ActivateGroupPacket))]
    [XmlInclude(typeof(SetGroupContributionPacket))]
    [XmlInclude(typeof(SetGroupAcceptNoticesPacket))]
    [XmlInclude(typeof(GroupRoleDataRequestPacket))]
    [XmlInclude(typeof(GroupRoleDataReplyPacket))]
    [XmlInclude(typeof(GroupRoleMembersRequestPacket))]
    [XmlInclude(typeof(GroupRoleMembersReplyPacket))]
    [XmlInclude(typeof(GroupTitlesRequestPacket))]
    [XmlInclude(typeof(GroupTitlesReplyPacket))]
    [XmlInclude(typeof(GroupTitleUpdatePacket))]
    [XmlInclude(typeof(GroupRoleUpdatePacket))]
    [XmlInclude(typeof(LiveHelpGroupRequestPacket))]
    [XmlInclude(typeof(LiveHelpGroupReplyPacket))]
    [XmlInclude(typeof(AgentWearablesRequestPacket))]
    [XmlInclude(typeof(AgentWearablesUpdatePacket))]
    [XmlInclude(typeof(AgentIsNowWearingPacket))]
    [XmlInclude(typeof(AgentCachedTexturePacket))]
    [XmlInclude(typeof(AgentCachedTextureResponsePacket))]
    [XmlInclude(typeof(AgentDataUpdateRequestPacket))]
    [XmlInclude(typeof(AgentDataUpdatePacket))]
    [XmlInclude(typeof(GroupDataUpdatePacket))]
    [XmlInclude(typeof(AgentGroupDataUpdatePacket))]
    [XmlInclude(typeof(AgentDropGroupPacket))]
    [XmlInclude(typeof(CreateTrustedCircuitPacket))]
    [XmlInclude(typeof(DenyTrustedCircuitPacket))]
    [XmlInclude(typeof(RequestTrustedCircuitPacket))]
    [XmlInclude(typeof(RezSingleAttachmentFromInvPacket))]
    [XmlInclude(typeof(RezMultipleAttachmentsFromInvPacket))]
    [XmlInclude(typeof(DetachAttachmentIntoInvPacket))]
    [XmlInclude(typeof(CreateNewOutfitAttachmentsPacket))]
    [XmlInclude(typeof(UserInfoRequestPacket))]
    [XmlInclude(typeof(UserInfoReplyPacket))]
    [XmlInclude(typeof(UpdateUserInfoPacket))]
    [XmlInclude(typeof(InitiateDownloadPacket))]
    [XmlInclude(typeof(SystemMessagePacket))]
    [XmlInclude(typeof(MapLayerRequestPacket))]
    [XmlInclude(typeof(MapLayerReplyPacket))]
    [XmlInclude(typeof(MapBlockRequestPacket))]
    [XmlInclude(typeof(MapNameRequestPacket))]
    [XmlInclude(typeof(MapBlockReplyPacket))]
    [XmlInclude(typeof(MapItemRequestPacket))]
    [XmlInclude(typeof(MapItemReplyPacket))]
    [XmlInclude(typeof(SendPostcardPacket))]
    [XmlInclude(typeof(ParcelMediaCommandMessagePacket))]
    [XmlInclude(typeof(ParcelMediaUpdatePacket))]
    [XmlInclude(typeof(LandStatRequestPacket))]
    [XmlInclude(typeof(LandStatReplyPacket))]
    [XmlInclude(typeof(ErrorPacket))]
    [XmlInclude(typeof(PacketAckPacket))]
    [XmlInclude(typeof(OpenCircuitPacket))]
    [XmlInclude(typeof(CloseCircuitPacket))]
    [XmlInclude(typeof(ObjectAddPacket))]
    [XmlInclude(typeof(MultipleObjectUpdatePacket))]
    [XmlInclude(typeof(RequestMultipleObjectsPacket))]
    [XmlInclude(typeof(ObjectPositionPacket))]
    [XmlInclude(typeof(RequestObjectPropertiesFamilyPacket))]
    [XmlInclude(typeof(CoarseLocationUpdatePacket))]
    [XmlInclude(typeof(CrossedRegionPacket))]
    [XmlInclude(typeof(ConfirmEnableSimulatorPacket))]
    [XmlInclude(typeof(ObjectPropertiesPacket))]
    [XmlInclude(typeof(ObjectPropertiesFamilyPacket))]
    [XmlInclude(typeof(ParcelPropertiesRequestPacket))]
    [XmlInclude(typeof(AttachedSoundPacket))]
    [XmlInclude(typeof(AttachedSoundGainChangePacket))]
    [XmlInclude(typeof(PreloadSoundPacket))]
    [XmlInclude(typeof(ViewerEffectPacket))]
    [XmlInclude(typeof(StartPingCheckPacket))]
    [XmlInclude(typeof(CompletePingCheckPacket))]
    [XmlInclude(typeof(AgentUpdatePacket))]
    [XmlInclude(typeof(AgentAnimationPacket))]
    [XmlInclude(typeof(AgentRequestSitPacket))]
    [XmlInclude(typeof(AgentSitPacket))]
    [XmlInclude(typeof(RequestImagePacket))]
    [XmlInclude(typeof(ImageDataPacket))]
    [XmlInclude(typeof(ImagePacketPacket))]
    [XmlInclude(typeof(LayerDataPacket))]
    [XmlInclude(typeof(ObjectUpdatePacket))]
    [XmlInclude(typeof(ObjectUpdateCompressedPacket))]
    [XmlInclude(typeof(ObjectUpdateCachedPacket))]
    [XmlInclude(typeof(ImprovedTerseObjectUpdatePacket))]
    [XmlInclude(typeof(KillObjectPacket))]
    [XmlInclude(typeof(TransferPacketPacket))]
    [XmlInclude(typeof(SendXferPacketPacket))]
    [XmlInclude(typeof(ConfirmXferPacketPacket))]
    [XmlInclude(typeof(AvatarAnimationPacket))]
    [XmlInclude(typeof(AvatarSitResponsePacket))]
    [XmlInclude(typeof(CameraConstraintPacket))]
    [XmlInclude(typeof(ParcelPropertiesPacket))]
    [XmlInclude(typeof(ChildAgentUpdatePacket))]
    [XmlInclude(typeof(ChildAgentAlivePacket))]
    [XmlInclude(typeof(ChildAgentPositionUpdatePacket))]
    [XmlInclude(typeof(SoundTriggerPacket))]
#endif
    public abstract class Packet
    {
        public abstract Header Header { get; set; }
        public abstract PacketType Type { get; }
        public int TickCount;

        public abstract byte[] ToBytes();

        public void ToXml(XmlWriter xmlWriter)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(Packet));
            serializer.Serialize(xmlWriter, this);
        }
        public static PacketType GetType(ushort id, PacketFrequency frequency)
        {
            switch (frequency)
            {
                case PacketFrequency.Low:
                    switch (id)
                    {
                        case 1: return PacketType.TestMessage;
                        case 3: return PacketType.UseCircuitCode;
                        case 10: return PacketType.TelehubInfo;
                        case 24: return PacketType.EconomyDataRequest;
                        case 25: return PacketType.EconomyData;
                        case 26: return PacketType.AvatarPickerRequest;
                        case 28: return PacketType.AvatarPickerReply;
                        case 29: return PacketType.PlacesQuery;
                        case 30: return PacketType.PlacesReply;
                        case 31: return PacketType.DirFindQuery;
                        case 33: return PacketType.DirPlacesQuery;
                        case 35: return PacketType.DirPlacesReply;
                        case 36: return PacketType.DirPeopleReply;
                        case 37: return PacketType.DirEventsReply;
                        case 38: return PacketType.DirGroupsReply;
                        case 39: return PacketType.DirClassifiedQuery;
                        case 41: return PacketType.DirClassifiedReply;
                        case 42: return PacketType.AvatarClassifiedReply;
                        case 43: return PacketType.ClassifiedInfoRequest;
                        case 44: return PacketType.ClassifiedInfoReply;
                        case 45: return PacketType.ClassifiedInfoUpdate;
                        case 46: return PacketType.ClassifiedDelete;
                        case 47: return PacketType.ClassifiedGodDelete;
                        case 48: return PacketType.DirLandQuery;
                        case 50: return PacketType.DirLandReply;
                        case 51: return PacketType.DirPopularQuery;
                        case 53: return PacketType.DirPopularReply;
                        case 54: return PacketType.ParcelInfoRequest;
                        case 55: return PacketType.ParcelInfoReply;
                        case 56: return PacketType.ParcelObjectOwnersRequest;
                        case 57: return PacketType.ParcelObjectOwnersReply;
                        case 58: return PacketType.GroupNoticesListRequest;
                        case 59: return PacketType.GroupNoticesListReply;
                        case 60: return PacketType.GroupNoticeRequest;
                        case 62: return PacketType.TeleportRequest;
                        case 63: return PacketType.TeleportLocationRequest;
                        case 64: return PacketType.TeleportLocal;
                        case 65: return PacketType.TeleportLandmarkRequest;
                        case 66: return PacketType.TeleportProgress;
                        case 69: return PacketType.TeleportFinish;
                        case 70: return PacketType.StartLure;
                        case 71: return PacketType.TeleportLureRequest;
                        case 72: return PacketType.TeleportCancel;
                        case 73: return PacketType.TeleportStart;
                        case 74: return PacketType.TeleportFailed;
                        case 75: return PacketType.Undo;
                        case 76: return PacketType.Redo;
                        case 77: return PacketType.UndoLand;
                        case 78: return PacketType.AgentPause;
                        case 79: return PacketType.AgentResume;
                        case 80: return PacketType.ChatFromViewer;
                        case 81: return PacketType.AgentThrottle;
                        case 82: return PacketType.AgentFOV;
                        case 83: return PacketType.AgentHeightWidth;
                        case 84: return PacketType.AgentSetAppearance;
                        case 85: return PacketType.AgentQuitCopy;
                        case 86: return PacketType.ImageNotInDatabase;
                        case 87: return PacketType.RebakeAvatarTextures;
                        case 88: return PacketType.SetAlwaysRun;
                        case 89: return PacketType.ObjectDelete;
                        case 90: return PacketType.ObjectDuplicate;
                        case 91: return PacketType.ObjectDuplicateOnRay;
                        case 92: return PacketType.ObjectScale;
                        case 93: return PacketType.ObjectRotation;
                        case 94: return PacketType.ObjectFlagUpdate;
                        case 95: return PacketType.ObjectClickAction;
                        case 96: return PacketType.ObjectImage;
                        case 97: return PacketType.ObjectMaterial;
                        case 98: return PacketType.ObjectShape;
                        case 99: return PacketType.ObjectExtraParams;
                        case 100: return PacketType.ObjectOwner;
                        case 101: return PacketType.ObjectGroup;
                        case 102: return PacketType.ObjectBuy;
                        case 103: return PacketType.BuyObjectInventory;
                        case 104: return PacketType.DerezContainer;
                        case 105: return PacketType.ObjectPermissions;
                        case 106: return PacketType.ObjectSaleInfo;
                        case 107: return PacketType.ObjectName;
                        case 108: return PacketType.ObjectDescription;
                        case 109: return PacketType.ObjectCategory;
                        case 110: return PacketType.ObjectSelect;
                        case 111: return PacketType.ObjectDeselect;
                        case 112: return PacketType.ObjectAttach;
                        case 113: return PacketType.ObjectDetach;
                        case 114: return PacketType.ObjectDrop;
                        case 115: return PacketType.ObjectLink;
                        case 116: return PacketType.ObjectDelink;
                        case 117: return PacketType.ObjectGrab;
                        case 118: return PacketType.ObjectGrabUpdate;
                        case 119: return PacketType.ObjectDeGrab;
                        case 120: return PacketType.ObjectSpinStart;
                        case 121: return PacketType.ObjectSpinUpdate;
                        case 122: return PacketType.ObjectSpinStop;
                        case 123: return PacketType.ObjectExportSelected;
                        case 124: return PacketType.ModifyLand;
                        case 125: return PacketType.VelocityInterpolateOn;
                        case 126: return PacketType.VelocityInterpolateOff;
                        case 127: return PacketType.StateSave;
                        case 128: return PacketType.ReportAutosaveCrash;
                        case 129: return PacketType.SimWideDeletes;
                        case 130: return PacketType.TrackAgent;
                        case 131: return PacketType.ViewerStats;
                        case 132: return PacketType.ScriptAnswerYes;
                        case 133: return PacketType.UserReport;
                        case 134: return PacketType.AlertMessage;
                        case 135: return PacketType.AgentAlertMessage;
                        case 136: return PacketType.MeanCollisionAlert;
                        case 137: return PacketType.ViewerFrozenMessage;
                        case 138: return PacketType.HealthMessage;
                        case 139: return PacketType.ChatFromSimulator;
                        case 140: return PacketType.SimStats;
                        case 141: return PacketType.RequestRegionInfo;
                        case 142: return PacketType.RegionInfo;
                        case 143: return PacketType.GodUpdateRegionInfo;
                        case 146: return PacketType.NearestLandingRegionUpdated;
                        case 148: return PacketType.RegionHandshake;
                        case 149: return PacketType.RegionHandshakeReply;
                        case 150: return PacketType.SimulatorViewerTimeMessage;
                        case 151: return PacketType.EnableSimulator;
                        case 152: return PacketType.DisableSimulator;
                        case 153: return PacketType.TransferRequest;
                        case 154: return PacketType.TransferInfo;
                        case 155: return PacketType.TransferAbort;
                        case 156: return PacketType.RequestXfer;
                        case 157: return PacketType.AbortXfer;
                        case 158: return PacketType.AvatarAppearance;
                        case 159: return PacketType.SetFollowCamProperties;
                        case 160: return PacketType.ClearFollowCamProperties;
                        case 161: return PacketType.RequestPayPrice;
                        case 162: return PacketType.PayPriceReply;
                        case 163: return PacketType.KickUser;
                        case 164: return PacketType.KickUserAck;
                        case 165: return PacketType.GodKickUser;
                        case 167: return PacketType.EjectUser;
                        case 168: return PacketType.FreezeUser;
                        case 169: return PacketType.AvatarPropertiesRequest;
                        case 171: return PacketType.AvatarPropertiesReply;
                        case 172: return PacketType.AvatarInterestsReply;
                        case 173: return PacketType.AvatarGroupsReply;
                        case 174: return PacketType.AvatarPropertiesUpdate;
                        case 175: return PacketType.AvatarInterestsUpdate;
                        case 176: return PacketType.AvatarNotesReply;
                        case 177: return PacketType.AvatarNotesUpdate;
                        case 178: return PacketType.AvatarPicksReply;
                        case 179: return PacketType.EventInfoRequest;
                        case 180: return PacketType.EventInfoReply;
                        case 181: return PacketType.EventNotificationAddRequest;
                        case 182: return PacketType.EventNotificationRemoveRequest;
                        case 183: return PacketType.EventGodDelete;
                        case 184: return PacketType.PickInfoReply;
                        case 185: return PacketType.PickInfoUpdate;
                        case 186: return PacketType.PickDelete;
                        case 187: return PacketType.PickGodDelete;
                        case 188: return PacketType.ScriptQuestion;
                        case 189: return PacketType.ScriptControlChange;
                        case 190: return PacketType.ScriptDialog;
                        case 191: return PacketType.ScriptDialogReply;
                        case 192: return PacketType.ForceScriptControlRelease;
                        case 193: return PacketType.RevokePermissions;
                        case 194: return PacketType.LoadURL;
                        case 195: return PacketType.ScriptTeleportRequest;
                        case 196: return PacketType.ParcelOverlay;
                        case 197: return PacketType.ParcelPropertiesRequestByID;
                        case 198: return PacketType.ParcelPropertiesUpdate;
                        case 199: return PacketType.ParcelReturnObjects;
                        case 200: return PacketType.ParcelSetOtherCleanTime;
                        case 201: return PacketType.ParcelDisableObjects;
                        case 202: return PacketType.ParcelSelectObjects;
                        case 203: return PacketType.EstateCovenantRequest;
                        case 204: return PacketType.EstateCovenantReply;
                        case 205: return PacketType.ForceObjectSelect;
                        case 206: return PacketType.ParcelBuyPass;
                        case 207: return PacketType.ParcelDeedToGroup;
                        case 208: return PacketType.ParcelReclaim;
                        case 209: return PacketType.ParcelClaim;
                        case 210: return PacketType.ParcelJoin;
                        case 211: return PacketType.ParcelDivide;
                        case 212: return PacketType.ParcelRelease;
                        case 213: return PacketType.ParcelBuy;
                        case 214: return PacketType.ParcelGodForceOwner;
                        case 215: return PacketType.ParcelAccessListRequest;
                        case 216: return PacketType.ParcelAccessListReply;
                        case 217: return PacketType.ParcelAccessListUpdate;
                        case 218: return PacketType.ParcelDwellRequest;
                        case 219: return PacketType.ParcelDwellReply;
                        case 227: return PacketType.ParcelGodMarkAsContent;
                        case 228: return PacketType.ViewerStartAuction;
                        case 235: return PacketType.UUIDNameRequest;
                        case 236: return PacketType.UUIDNameReply;
                        case 237: return PacketType.UUIDGroupNameRequest;
                        case 238: return PacketType.UUIDGroupNameReply;
                        case 240: return PacketType.ChildAgentDying;
                        case 241: return PacketType.ChildAgentUnknown;
                        case 243: return PacketType.GetScriptRunning;
                        case 244: return PacketType.ScriptRunningReply;
                        case 245: return PacketType.SetScriptRunning;
                        case 246: return PacketType.ScriptReset;
                        case 247: return PacketType.ScriptSensorRequest;
                        case 248: return PacketType.ScriptSensorReply;
                        case 249: return PacketType.CompleteAgentMovement;
                        case 250: return PacketType.AgentMovementComplete;
                        case 252: return PacketType.LogoutRequest;
                        case 253: return PacketType.LogoutReply;
                        case 254: return PacketType.ImprovedInstantMessage;
                        case 255: return PacketType.RetrieveInstantMessages;
                        case 256: return PacketType.FindAgent;
                        case 257: return PacketType.RequestGodlikePowers;
                        case 258: return PacketType.GrantGodlikePowers;
                        case 259: return PacketType.GodlikeMessage;
                        case 260: return PacketType.EstateOwnerMessage;
                        case 261: return PacketType.GenericMessage;
                        case 262: return PacketType.MuteListRequest;
                        case 263: return PacketType.UpdateMuteListEntry;
                        case 264: return PacketType.RemoveMuteListEntry;
                        case 265: return PacketType.CopyInventoryFromNotecard;
                        case 266: return PacketType.UpdateInventoryItem;
                        case 267: return PacketType.UpdateCreateInventoryItem;
                        case 268: return PacketType.MoveInventoryItem;
                        case 269: return PacketType.CopyInventoryItem;
                        case 270: return PacketType.RemoveInventoryItem;
                        case 271: return PacketType.ChangeInventoryItemFlags;
                        case 272: return PacketType.SaveAssetIntoInventory;
                        case 273: return PacketType.CreateInventoryFolder;
                        case 274: return PacketType.UpdateInventoryFolder;
                        case 275: return PacketType.MoveInventoryFolder;
                        case 276: return PacketType.RemoveInventoryFolder;
                        case 277: return PacketType.FetchInventoryDescendents;
                        case 278: return PacketType.InventoryDescendents;
                        case 279: return PacketType.FetchInventory;
                        case 280: return PacketType.FetchInventoryReply;
                        case 281: return PacketType.BulkUpdateInventory;
                        case 282: return PacketType.RequestInventoryAsset;
                        case 283: return PacketType.InventoryAssetResponse;
                        case 284: return PacketType.RemoveInventoryObjects;
                        case 285: return PacketType.PurgeInventoryDescendents;
                        case 286: return PacketType.UpdateTaskInventory;
                        case 287: return PacketType.RemoveTaskInventory;
                        case 288: return PacketType.MoveTaskInventory;
                        case 289: return PacketType.RequestTaskInventory;
                        case 290: return PacketType.ReplyTaskInventory;
                        case 291: return PacketType.DeRezObject;
                        case 292: return PacketType.DeRezAck;
                        case 293: return PacketType.RezObject;
                        case 294: return PacketType.RezObjectFromNotecard;
                        case 297: return PacketType.AcceptFriendship;
                        case 298: return PacketType.DeclineFriendship;
                        case 299: return PacketType.FormFriendship;
                        case 300: return PacketType.TerminateFriendship;
                        case 301: return PacketType.OfferCallingCard;
                        case 302: return PacketType.AcceptCallingCard;
                        case 303: return PacketType.DeclineCallingCard;
                        case 304: return PacketType.RezScript;
                        case 305: return PacketType.CreateInventoryItem;
                        case 306: return PacketType.CreateLandmarkForEvent;
                        case 309: return PacketType.RegionHandleRequest;
                        case 310: return PacketType.RegionIDAndHandleReply;
                        case 311: return PacketType.MoneyTransferRequest;
                        case 313: return PacketType.MoneyBalanceRequest;
                        case 314: return PacketType.MoneyBalanceReply;
                        case 315: return PacketType.RoutedMoneyBalanceReply;
                        case 316: return PacketType.ActivateGestures;
                        case 317: return PacketType.DeactivateGestures;
                        case 318: return PacketType.MuteListUpdate;
                        case 319: return PacketType.UseCachedMuteList;
                        case 320: return PacketType.GrantUserRights;
                        case 321: return PacketType.ChangeUserRights;
                        case 322: return PacketType.OnlineNotification;
                        case 323: return PacketType.OfflineNotification;
                        case 324: return PacketType.SetStartLocationRequest;
                        case 333: return PacketType.AssetUploadRequest;
                        case 334: return PacketType.AssetUploadComplete;
                        case 339: return PacketType.CreateGroupRequest;
                        case 340: return PacketType.CreateGroupReply;
                        case 341: return PacketType.UpdateGroupInfo;
                        case 342: return PacketType.GroupRoleChanges;
                        case 343: return PacketType.JoinGroupRequest;
                        case 344: return PacketType.JoinGroupReply;
                        case 345: return PacketType.EjectGroupMemberRequest;
                        case 346: return PacketType.EjectGroupMemberReply;
                        case 347: return PacketType.LeaveGroupRequest;
                        case 348: return PacketType.LeaveGroupReply;
                        case 349: return PacketType.InviteGroupRequest;
                        case 351: return PacketType.GroupProfileRequest;
                        case 352: return PacketType.GroupProfileReply;
                        case 353: return PacketType.GroupAccountSummaryRequest;
                        case 354: return PacketType.GroupAccountSummaryReply;
                        case 355: return PacketType.GroupAccountDetailsRequest;
                        case 356: return PacketType.GroupAccountDetailsReply;
                        case 357: return PacketType.GroupAccountTransactionsRequest;
                        case 358: return PacketType.GroupAccountTransactionsReply;
                        case 359: return PacketType.GroupActiveProposalsRequest;
                        case 360: return PacketType.GroupActiveProposalItemReply;
                        case 361: return PacketType.GroupVoteHistoryRequest;
                        case 362: return PacketType.GroupVoteHistoryItemReply;
                        case 363: return PacketType.StartGroupProposal;
                        case 364: return PacketType.GroupProposalBallot;
                        case 366: return PacketType.GroupMembersRequest;
                        case 367: return PacketType.GroupMembersReply;
                        case 368: return PacketType.ActivateGroup;
                        case 369: return PacketType.SetGroupContribution;
                        case 370: return PacketType.SetGroupAcceptNotices;
                        case 371: return PacketType.GroupRoleDataRequest;
                        case 372: return PacketType.GroupRoleDataReply;
                        case 373: return PacketType.GroupRoleMembersRequest;
                        case 374: return PacketType.GroupRoleMembersReply;
                        case 375: return PacketType.GroupTitlesRequest;
                        case 376: return PacketType.GroupTitlesReply;
                        case 377: return PacketType.GroupTitleUpdate;
                        case 378: return PacketType.GroupRoleUpdate;
                        case 379: return PacketType.LiveHelpGroupRequest;
                        case 380: return PacketType.LiveHelpGroupReply;
                        case 381: return PacketType.AgentWearablesRequest;
                        case 382: return PacketType.AgentWearablesUpdate;
                        case 383: return PacketType.AgentIsNowWearing;
                        case 384: return PacketType.AgentCachedTexture;
                        case 385: return PacketType.AgentCachedTextureResponse;
                        case 386: return PacketType.AgentDataUpdateRequest;
                        case 387: return PacketType.AgentDataUpdate;
                        case 388: return PacketType.GroupDataUpdate;
                        case 389: return PacketType.AgentGroupDataUpdate;
                        case 390: return PacketType.AgentDropGroup;
                        case 392: return PacketType.CreateTrustedCircuit;
                        case 393: return PacketType.DenyTrustedCircuit;
                        case 394: return PacketType.RequestTrustedCircuit;
                        case 395: return PacketType.RezSingleAttachmentFromInv;
                        case 396: return PacketType.RezMultipleAttachmentsFromInv;
                        case 397: return PacketType.DetachAttachmentIntoInv;
                        case 398: return PacketType.CreateNewOutfitAttachments;
                        case 399: return PacketType.UserInfoRequest;
                        case 400: return PacketType.UserInfoReply;
                        case 401: return PacketType.UpdateUserInfo;
                        case 403: return PacketType.InitiateDownload;
                        case 404: return PacketType.SystemMessage;
                        case 405: return PacketType.MapLayerRequest;
                        case 406: return PacketType.MapLayerReply;
                        case 407: return PacketType.MapBlockRequest;
                        case 408: return PacketType.MapNameRequest;
                        case 409: return PacketType.MapBlockReply;
                        case 410: return PacketType.MapItemRequest;
                        case 411: return PacketType.MapItemReply;
                        case 412: return PacketType.SendPostcard;
                        case 419: return PacketType.ParcelMediaCommandMessage;
                        case 420: return PacketType.ParcelMediaUpdate;
                        case 421: return PacketType.LandStatRequest;
                        case 422: return PacketType.LandStatReply;
                        case 423: return PacketType.Error;
                        case 65531: return PacketType.PacketAck;
                        case 65532: return PacketType.OpenCircuit;
                        case 65533: return PacketType.CloseCircuit;
                    }
                    break;
                case PacketFrequency.Medium:
                    switch (id)
                    {
                        case 1: return PacketType.ObjectAdd;
                        case 2: return PacketType.MultipleObjectUpdate;
                        case 3: return PacketType.RequestMultipleObjects;
                        case 4: return PacketType.ObjectPosition;
                        case 5: return PacketType.RequestObjectPropertiesFamily;
                        case 6: return PacketType.CoarseLocationUpdate;
                        case 7: return PacketType.CrossedRegion;
                        case 8: return PacketType.ConfirmEnableSimulator;
                        case 9: return PacketType.ObjectProperties;
                        case 10: return PacketType.ObjectPropertiesFamily;
                        case 11: return PacketType.ParcelPropertiesRequest;
                        case 13: return PacketType.AttachedSound;
                        case 14: return PacketType.AttachedSoundGainChange;
                        case 15: return PacketType.PreloadSound;
                        case 17: return PacketType.ViewerEffect;
                    }
                    break;
                case PacketFrequency.High:
                    switch (id)
                    {
                        case 1: return PacketType.StartPingCheck;
                        case 2: return PacketType.CompletePingCheck;
                        case 4: return PacketType.AgentUpdate;
                        case 5: return PacketType.AgentAnimation;
                        case 6: return PacketType.AgentRequestSit;
                        case 7: return PacketType.AgentSit;
                        case 8: return PacketType.RequestImage;
                        case 9: return PacketType.ImageData;
                        case 10: return PacketType.ImagePacket;
                        case 11: return PacketType.LayerData;
                        case 12: return PacketType.ObjectUpdate;
                        case 13: return PacketType.ObjectUpdateCompressed;
                        case 14: return PacketType.ObjectUpdateCached;
                        case 15: return PacketType.ImprovedTerseObjectUpdate;
                        case 16: return PacketType.KillObject;
                        case 17: return PacketType.TransferPacket;
                        case 18: return PacketType.SendXferPacket;
                        case 19: return PacketType.ConfirmXferPacket;
                        case 20: return PacketType.AvatarAnimation;
                        case 21: return PacketType.AvatarSitResponse;
                        case 22: return PacketType.CameraConstraint;
                        case 23: return PacketType.ParcelProperties;
                        case 25: return PacketType.ChildAgentUpdate;
                        case 26: return PacketType.ChildAgentAlive;
                        case 27: return PacketType.ChildAgentPositionUpdate;
                        case 29: return PacketType.SoundTrigger;
                    }
                    break;
            }

            return PacketType.Default;
        }

        public static Packet BuildPacket(byte[] bytes, ref int packetEnd, byte[] zeroBuffer)
        {
            ushort id; PacketFrequency freq;
            int i = 0;
            Header header = Header.BuildHeader(bytes, ref i, ref packetEnd);
            if (header.Zerocoded)
            {
                packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
                bytes = zeroBuffer;
            }

            if (bytes[6] == 0xFF)
            {
                if (bytes[7] == 0xFF)
                {
                    id = (ushort)((bytes[8] << 8) + bytes[9]); freq = PacketFrequency.Low;
                    switch (id)
                    {
                        case 1: return new TestMessagePacket(header, bytes, ref i);
                        case 3: return new UseCircuitCodePacket(header, bytes, ref i);
                        case 10: return new TelehubInfoPacket(header, bytes, ref i);
                        case 24: return new EconomyDataRequestPacket(header, bytes, ref i);
                        case 25: return new EconomyDataPacket(header, bytes, ref i);
                        case 26: return new AvatarPickerRequestPacket(header, bytes, ref i);
                        case 28: return new AvatarPickerReplyPacket(header, bytes, ref i);
                        case 29: return new PlacesQueryPacket(header, bytes, ref i);
                        case 30: return new PlacesReplyPacket(header, bytes, ref i);
                        case 31: return new DirFindQueryPacket(header, bytes, ref i);
                        case 33: return new DirPlacesQueryPacket(header, bytes, ref i);
                        case 35: return new DirPlacesReplyPacket(header, bytes, ref i);
                        case 36: return new DirPeopleReplyPacket(header, bytes, ref i);
                        case 37: return new DirEventsReplyPacket(header, bytes, ref i);
                        case 38: return new DirGroupsReplyPacket(header, bytes, ref i);
                        case 39: return new DirClassifiedQueryPacket(header, bytes, ref i);
                        case 41: return new DirClassifiedReplyPacket(header, bytes, ref i);
                        case 42: return new AvatarClassifiedReplyPacket(header, bytes, ref i);
                        case 43: return new ClassifiedInfoRequestPacket(header, bytes, ref i);
                        case 44: return new ClassifiedInfoReplyPacket(header, bytes, ref i);
                        case 45: return new ClassifiedInfoUpdatePacket(header, bytes, ref i);
                        case 46: return new ClassifiedDeletePacket(header, bytes, ref i);
                        case 47: return new ClassifiedGodDeletePacket(header, bytes, ref i);
                        case 48: return new DirLandQueryPacket(header, bytes, ref i);
                        case 50: return new DirLandReplyPacket(header, bytes, ref i);
                        case 51: return new DirPopularQueryPacket(header, bytes, ref i);
                        case 53: return new DirPopularReplyPacket(header, bytes, ref i);
                        case 54: return new ParcelInfoRequestPacket(header, bytes, ref i);
                        case 55: return new ParcelInfoReplyPacket(header, bytes, ref i);
                        case 56: return new ParcelObjectOwnersRequestPacket(header, bytes, ref i);
                        case 57: return new ParcelObjectOwnersReplyPacket(header, bytes, ref i);
                        case 58: return new GroupNoticesListRequestPacket(header, bytes, ref i);
                        case 59: return new GroupNoticesListReplyPacket(header, bytes, ref i);
                        case 60: return new GroupNoticeRequestPacket(header, bytes, ref i);
                        case 62: return new TeleportRequestPacket(header, bytes, ref i);
                        case 63: return new TeleportLocationRequestPacket(header, bytes, ref i);
                        case 64: return new TeleportLocalPacket(header, bytes, ref i);
                        case 65: return new TeleportLandmarkRequestPacket(header, bytes, ref i);
                        case 66: return new TeleportProgressPacket(header, bytes, ref i);
                        case 69: return new TeleportFinishPacket(header, bytes, ref i);
                        case 70: return new StartLurePacket(header, bytes, ref i);
                        case 71: return new TeleportLureRequestPacket(header, bytes, ref i);
                        case 72: return new TeleportCancelPacket(header, bytes, ref i);
                        case 73: return new TeleportStartPacket(header, bytes, ref i);
                        case 74: return new TeleportFailedPacket(header, bytes, ref i);
                        case 75: return new UndoPacket(header, bytes, ref i);
                        case 76: return new RedoPacket(header, bytes, ref i);
                        case 77: return new UndoLandPacket(header, bytes, ref i);
                        case 78: return new AgentPausePacket(header, bytes, ref i);
                        case 79: return new AgentResumePacket(header, bytes, ref i);
                        case 80: return new ChatFromViewerPacket(header, bytes, ref i);
                        case 81: return new AgentThrottlePacket(header, bytes, ref i);
                        case 82: return new AgentFOVPacket(header, bytes, ref i);
                        case 83: return new AgentHeightWidthPacket(header, bytes, ref i);
                        case 84: return new AgentSetAppearancePacket(header, bytes, ref i);
                        case 85: return new AgentQuitCopyPacket(header, bytes, ref i);
                        case 86: return new ImageNotInDatabasePacket(header, bytes, ref i);
                        case 87: return new RebakeAvatarTexturesPacket(header, bytes, ref i);
                        case 88: return new SetAlwaysRunPacket(header, bytes, ref i);
                        case 89: return new ObjectDeletePacket(header, bytes, ref i);
                        case 90: return new ObjectDuplicatePacket(header, bytes, ref i);
                        case 91: return new ObjectDuplicateOnRayPacket(header, bytes, ref i);
                        case 92: return new ObjectScalePacket(header, bytes, ref i);
                        case 93: return new ObjectRotationPacket(header, bytes, ref i);
                        case 94: return new ObjectFlagUpdatePacket(header, bytes, ref i);
                        case 95: return new ObjectClickActionPacket(header, bytes, ref i);
                        case 96: return new ObjectImagePacket(header, bytes, ref i);
                        case 97: return new ObjectMaterialPacket(header, bytes, ref i);
                        case 98: return new ObjectShapePacket(header, bytes, ref i);
                        case 99: return new ObjectExtraParamsPacket(header, bytes, ref i);
                        case 100: return new ObjectOwnerPacket(header, bytes, ref i);
                        case 101: return new ObjectGroupPacket(header, bytes, ref i);
                        case 102: return new ObjectBuyPacket(header, bytes, ref i);
                        case 103: return new BuyObjectInventoryPacket(header, bytes, ref i);
                        case 104: return new DerezContainerPacket(header, bytes, ref i);
                        case 105: return new ObjectPermissionsPacket(header, bytes, ref i);
                        case 106: return new ObjectSaleInfoPacket(header, bytes, ref i);
                        case 107: return new ObjectNamePacket(header, bytes, ref i);
                        case 108: return new ObjectDescriptionPacket(header, bytes, ref i);
                        case 109: return new ObjectCategoryPacket(header, bytes, ref i);
                        case 110: return new ObjectSelectPacket(header, bytes, ref i);
                        case 111: return new ObjectDeselectPacket(header, bytes, ref i);
                        case 112: return new ObjectAttachPacket(header, bytes, ref i);
                        case 113: return new ObjectDetachPacket(header, bytes, ref i);
                        case 114: return new ObjectDropPacket(header, bytes, ref i);
                        case 115: return new ObjectLinkPacket(header, bytes, ref i);
                        case 116: return new ObjectDelinkPacket(header, bytes, ref i);
                        case 117: return new ObjectGrabPacket(header, bytes, ref i);
                        case 118: return new ObjectGrabUpdatePacket(header, bytes, ref i);
                        case 119: return new ObjectDeGrabPacket(header, bytes, ref i);
                        case 120: return new ObjectSpinStartPacket(header, bytes, ref i);
                        case 121: return new ObjectSpinUpdatePacket(header, bytes, ref i);
                        case 122: return new ObjectSpinStopPacket(header, bytes, ref i);
                        case 123: return new ObjectExportSelectedPacket(header, bytes, ref i);
                        case 124: return new ModifyLandPacket(header, bytes, ref i);
                        case 125: return new VelocityInterpolateOnPacket(header, bytes, ref i);
                        case 126: return new VelocityInterpolateOffPacket(header, bytes, ref i);
                        case 127: return new StateSavePacket(header, bytes, ref i);
                        case 128: return new ReportAutosaveCrashPacket(header, bytes, ref i);
                        case 129: return new SimWideDeletesPacket(header, bytes, ref i);
                        case 130: return new TrackAgentPacket(header, bytes, ref i);
                        case 131: return new ViewerStatsPacket(header, bytes, ref i);
                        case 132: return new ScriptAnswerYesPacket(header, bytes, ref i);
                        case 133: return new UserReportPacket(header, bytes, ref i);
                        case 134: return new AlertMessagePacket(header, bytes, ref i);
                        case 135: return new AgentAlertMessagePacket(header, bytes, ref i);
                        case 136: return new MeanCollisionAlertPacket(header, bytes, ref i);
                        case 137: return new ViewerFrozenMessagePacket(header, bytes, ref i);
                        case 138: return new HealthMessagePacket(header, bytes, ref i);
                        case 139: return new ChatFromSimulatorPacket(header, bytes, ref i);
                        case 140: return new SimStatsPacket(header, bytes, ref i);
                        case 141: return new RequestRegionInfoPacket(header, bytes, ref i);
                        case 142: return new RegionInfoPacket(header, bytes, ref i);
                        case 143: return new GodUpdateRegionInfoPacket(header, bytes, ref i);
                        case 146: return new NearestLandingRegionUpdatedPacket(header, bytes, ref i);
                        case 148: return new RegionHandshakePacket(header, bytes, ref i);
                        case 149: return new RegionHandshakeReplyPacket(header, bytes, ref i);
                        case 150: return new SimulatorViewerTimeMessagePacket(header, bytes, ref i);
                        case 151: return new EnableSimulatorPacket(header, bytes, ref i);
                        case 152: return new DisableSimulatorPacket(header, bytes, ref i);
                        case 153: return new TransferRequestPacket(header, bytes, ref i);
                        case 154: return new TransferInfoPacket(header, bytes, ref i);
                        case 155: return new TransferAbortPacket(header, bytes, ref i);
                        case 156: return new RequestXferPacket(header, bytes, ref i);
                        case 157: return new AbortXferPacket(header, bytes, ref i);
                        case 158: return new AvatarAppearancePacket(header, bytes, ref i);
                        case 159: return new SetFollowCamPropertiesPacket(header, bytes, ref i);
                        case 160: return new ClearFollowCamPropertiesPacket(header, bytes, ref i);
                        case 161: return new RequestPayPricePacket(header, bytes, ref i);
                        case 162: return new PayPriceReplyPacket(header, bytes, ref i);
                        case 163: return new KickUserPacket(header, bytes, ref i);
                        case 164: return new KickUserAckPacket(header, bytes, ref i);
                        case 165: return new GodKickUserPacket(header, bytes, ref i);
                        case 167: return new EjectUserPacket(header, bytes, ref i);
                        case 168: return new FreezeUserPacket(header, bytes, ref i);
                        case 169: return new AvatarPropertiesRequestPacket(header, bytes, ref i);
                        case 171: return new AvatarPropertiesReplyPacket(header, bytes, ref i);
                        case 172: return new AvatarInterestsReplyPacket(header, bytes, ref i);
                        case 173: return new AvatarGroupsReplyPacket(header, bytes, ref i);
                        case 174: return new AvatarPropertiesUpdatePacket(header, bytes, ref i);
                        case 175: return new AvatarInterestsUpdatePacket(header, bytes, ref i);
                        case 176: return new AvatarNotesReplyPacket(header, bytes, ref i);
                        case 177: return new AvatarNotesUpdatePacket(header, bytes, ref i);
                        case 178: return new AvatarPicksReplyPacket(header, bytes, ref i);
                        case 179: return new EventInfoRequestPacket(header, bytes, ref i);
                        case 180: return new EventInfoReplyPacket(header, bytes, ref i);
                        case 181: return new EventNotificationAddRequestPacket(header, bytes, ref i);
                        case 182: return new EventNotificationRemoveRequestPacket(header, bytes, ref i);
                        case 183: return new EventGodDeletePacket(header, bytes, ref i);
                        case 184: return new PickInfoReplyPacket(header, bytes, ref i);
                        case 185: return new PickInfoUpdatePacket(header, bytes, ref i);
                        case 186: return new PickDeletePacket(header, bytes, ref i);
                        case 187: return new PickGodDeletePacket(header, bytes, ref i);
                        case 188: return new ScriptQuestionPacket(header, bytes, ref i);
                        case 189: return new ScriptControlChangePacket(header, bytes, ref i);
                        case 190: return new ScriptDialogPacket(header, bytes, ref i);
                        case 191: return new ScriptDialogReplyPacket(header, bytes, ref i);
                        case 192: return new ForceScriptControlReleasePacket(header, bytes, ref i);
                        case 193: return new RevokePermissionsPacket(header, bytes, ref i);
                        case 194: return new LoadURLPacket(header, bytes, ref i);
                        case 195: return new ScriptTeleportRequestPacket(header, bytes, ref i);
                        case 196: return new ParcelOverlayPacket(header, bytes, ref i);
                        case 197: return new ParcelPropertiesRequestByIDPacket(header, bytes, ref i);
                        case 198: return new ParcelPropertiesUpdatePacket(header, bytes, ref i);
                        case 199: return new ParcelReturnObjectsPacket(header, bytes, ref i);
                        case 200: return new ParcelSetOtherCleanTimePacket(header, bytes, ref i);
                        case 201: return new ParcelDisableObjectsPacket(header, bytes, ref i);
                        case 202: return new ParcelSelectObjectsPacket(header, bytes, ref i);
                        case 203: return new EstateCovenantRequestPacket(header, bytes, ref i);
                        case 204: return new EstateCovenantReplyPacket(header, bytes, ref i);
                        case 205: return new ForceObjectSelectPacket(header, bytes, ref i);
                        case 206: return new ParcelBuyPassPacket(header, bytes, ref i);
                        case 207: return new ParcelDeedToGroupPacket(header, bytes, ref i);
                        case 208: return new ParcelReclaimPacket(header, bytes, ref i);
                        case 209: return new ParcelClaimPacket(header, bytes, ref i);
                        case 210: return new ParcelJoinPacket(header, bytes, ref i);
                        case 211: return new ParcelDividePacket(header, bytes, ref i);
                        case 212: return new ParcelReleasePacket(header, bytes, ref i);
                        case 213: return new ParcelBuyPacket(header, bytes, ref i);
                        case 214: return new ParcelGodForceOwnerPacket(header, bytes, ref i);
                        case 215: return new ParcelAccessListRequestPacket(header, bytes, ref i);
                        case 216: return new ParcelAccessListReplyPacket(header, bytes, ref i);
                        case 217: return new ParcelAccessListUpdatePacket(header, bytes, ref i);
                        case 218: return new ParcelDwellRequestPacket(header, bytes, ref i);
                        case 219: return new ParcelDwellReplyPacket(header, bytes, ref i);
                        case 227: return new ParcelGodMarkAsContentPacket(header, bytes, ref i);
                        case 228: return new ViewerStartAuctionPacket(header, bytes, ref i);
                        case 235: return new UUIDNameRequestPacket(header, bytes, ref i);
                        case 236: return new UUIDNameReplyPacket(header, bytes, ref i);
                        case 237: return new UUIDGroupNameRequestPacket(header, bytes, ref i);
                        case 238: return new UUIDGroupNameReplyPacket(header, bytes, ref i);
                        case 240: return new ChildAgentDyingPacket(header, bytes, ref i);
                        case 241: return new ChildAgentUnknownPacket(header, bytes, ref i);
                        case 243: return new GetScriptRunningPacket(header, bytes, ref i);
                        case 244: return new ScriptRunningReplyPacket(header, bytes, ref i);
                        case 245: return new SetScriptRunningPacket(header, bytes, ref i);
                        case 246: return new ScriptResetPacket(header, bytes, ref i);
                        case 247: return new ScriptSensorRequestPacket(header, bytes, ref i);
                        case 248: return new ScriptSensorReplyPacket(header, bytes, ref i);
                        case 249: return new CompleteAgentMovementPacket(header, bytes, ref i);
                        case 250: return new AgentMovementCompletePacket(header, bytes, ref i);
                        case 252: return new LogoutRequestPacket(header, bytes, ref i);
                        case 253: return new LogoutReplyPacket(header, bytes, ref i);
                        case 254: return new ImprovedInstantMessagePacket(header, bytes, ref i);
                        case 255: return new RetrieveInstantMessagesPacket(header, bytes, ref i);
                        case 256: return new FindAgentPacket(header, bytes, ref i);
                        case 257: return new RequestGodlikePowersPacket(header, bytes, ref i);
                        case 258: return new GrantGodlikePowersPacket(header, bytes, ref i);
                        case 259: return new GodlikeMessagePacket(header, bytes, ref i);
                        case 260: return new EstateOwnerMessagePacket(header, bytes, ref i);
                        case 261: return new GenericMessagePacket(header, bytes, ref i);
                        case 262: return new MuteListRequestPacket(header, bytes, ref i);
                        case 263: return new UpdateMuteListEntryPacket(header, bytes, ref i);
                        case 264: return new RemoveMuteListEntryPacket(header, bytes, ref i);
                        case 265: return new CopyInventoryFromNotecardPacket(header, bytes, ref i);
                        case 266: return new UpdateInventoryItemPacket(header, bytes, ref i);
                        case 267: return new UpdateCreateInventoryItemPacket(header, bytes, ref i);
                        case 268: return new MoveInventoryItemPacket(header, bytes, ref i);
                        case 269: return new CopyInventoryItemPacket(header, bytes, ref i);
                        case 270: return new RemoveInventoryItemPacket(header, bytes, ref i);
                        case 271: return new ChangeInventoryItemFlagsPacket(header, bytes, ref i);
                        case 272: return new SaveAssetIntoInventoryPacket(header, bytes, ref i);
                        case 273: return new CreateInventoryFolderPacket(header, bytes, ref i);
                        case 274: return new UpdateInventoryFolderPacket(header, bytes, ref i);
                        case 275: return new MoveInventoryFolderPacket(header, bytes, ref i);
                        case 276: return new RemoveInventoryFolderPacket(header, bytes, ref i);
                        case 277: return new FetchInventoryDescendentsPacket(header, bytes, ref i);
                        case 278: return new InventoryDescendentsPacket(header, bytes, ref i);
                        case 279: return new FetchInventoryPacket(header, bytes, ref i);
                        case 280: return new FetchInventoryReplyPacket(header, bytes, ref i);
                        case 281: return new BulkUpdateInventoryPacket(header, bytes, ref i);
                        case 282: return new RequestInventoryAssetPacket(header, bytes, ref i);
                        case 283: return new InventoryAssetResponsePacket(header, bytes, ref i);
                        case 284: return new RemoveInventoryObjectsPacket(header, bytes, ref i);
                        case 285: return new PurgeInventoryDescendentsPacket(header, bytes, ref i);
                        case 286: return new UpdateTaskInventoryPacket(header, bytes, ref i);
                        case 287: return new RemoveTaskInventoryPacket(header, bytes, ref i);
                        case 288: return new MoveTaskInventoryPacket(header, bytes, ref i);
                        case 289: return new RequestTaskInventoryPacket(header, bytes, ref i);
                        case 290: return new ReplyTaskInventoryPacket(header, bytes, ref i);
                        case 291: return new DeRezObjectPacket(header, bytes, ref i);
                        case 292: return new DeRezAckPacket(header, bytes, ref i);
                        case 293: return new RezObjectPacket(header, bytes, ref i);
                        case 294: return new RezObjectFromNotecardPacket(header, bytes, ref i);
                        case 297: return new AcceptFriendshipPacket(header, bytes, ref i);
                        case 298: return new DeclineFriendshipPacket(header, bytes, ref i);
                        case 299: return new FormFriendshipPacket(header, bytes, ref i);
                        case 300: return new TerminateFriendshipPacket(header, bytes, ref i);
                        case 301: return new OfferCallingCardPacket(header, bytes, ref i);
                        case 302: return new AcceptCallingCardPacket(header, bytes, ref i);
                        case 303: return new DeclineCallingCardPacket(header, bytes, ref i);
                        case 304: return new RezScriptPacket(header, bytes, ref i);
                        case 305: return new CreateInventoryItemPacket(header, bytes, ref i);
                        case 306: return new CreateLandmarkForEventPacket(header, bytes, ref i);
                        case 309: return new RegionHandleRequestPacket(header, bytes, ref i);
                        case 310: return new RegionIDAndHandleReplyPacket(header, bytes, ref i);
                        case 311: return new MoneyTransferRequestPacket(header, bytes, ref i);
                        case 313: return new MoneyBalanceRequestPacket(header, bytes, ref i);
                        case 314: return new MoneyBalanceReplyPacket(header, bytes, ref i);
                        case 315: return new RoutedMoneyBalanceReplyPacket(header, bytes, ref i);
                        case 316: return new ActivateGesturesPacket(header, bytes, ref i);
                        case 317: return new DeactivateGesturesPacket(header, bytes, ref i);
                        case 318: return new MuteListUpdatePacket(header, bytes, ref i);
                        case 319: return new UseCachedMuteListPacket(header, bytes, ref i);
                        case 320: return new GrantUserRightsPacket(header, bytes, ref i);
                        case 321: return new ChangeUserRightsPacket(header, bytes, ref i);
                        case 322: return new OnlineNotificationPacket(header, bytes, ref i);
                        case 323: return new OfflineNotificationPacket(header, bytes, ref i);
                        case 324: return new SetStartLocationRequestPacket(header, bytes, ref i);
                        case 333: return new AssetUploadRequestPacket(header, bytes, ref i);
                        case 334: return new AssetUploadCompletePacket(header, bytes, ref i);
                        case 339: return new CreateGroupRequestPacket(header, bytes, ref i);
                        case 340: return new CreateGroupReplyPacket(header, bytes, ref i);
                        case 341: return new UpdateGroupInfoPacket(header, bytes, ref i);
                        case 342: return new GroupRoleChangesPacket(header, bytes, ref i);
                        case 343: return new JoinGroupRequestPacket(header, bytes, ref i);
                        case 344: return new JoinGroupReplyPacket(header, bytes, ref i);
                        case 345: return new EjectGroupMemberRequestPacket(header, bytes, ref i);
                        case 346: return new EjectGroupMemberReplyPacket(header, bytes, ref i);
                        case 347: return new LeaveGroupRequestPacket(header, bytes, ref i);
                        case 348: return new LeaveGroupReplyPacket(header, bytes, ref i);
                        case 349: return new InviteGroupRequestPacket(header, bytes, ref i);
                        case 351: return new GroupProfileRequestPacket(header, bytes, ref i);
                        case 352: return new GroupProfileReplyPacket(header, bytes, ref i);
                        case 353: return new GroupAccountSummaryRequestPacket(header, bytes, ref i);
                        case 354: return new GroupAccountSummaryReplyPacket(header, bytes, ref i);
                        case 355: return new GroupAccountDetailsRequestPacket(header, bytes, ref i);
                        case 356: return new GroupAccountDetailsReplyPacket(header, bytes, ref i);
                        case 357: return new GroupAccountTransactionsRequestPacket(header, bytes, ref i);
                        case 358: return new GroupAccountTransactionsReplyPacket(header, bytes, ref i);
                        case 359: return new GroupActiveProposalsRequestPacket(header, bytes, ref i);
                        case 360: return new GroupActiveProposalItemReplyPacket(header, bytes, ref i);
                        case 361: return new GroupVoteHistoryRequestPacket(header, bytes, ref i);
                        case 362: return new GroupVoteHistoryItemReplyPacket(header, bytes, ref i);
                        case 363: return new StartGroupProposalPacket(header, bytes, ref i);
                        case 364: return new GroupProposalBallotPacket(header, bytes, ref i);
                        case 366: return new GroupMembersRequestPacket(header, bytes, ref i);
                        case 367: return new GroupMembersReplyPacket(header, bytes, ref i);
                        case 368: return new ActivateGroupPacket(header, bytes, ref i);
                        case 369: return new SetGroupContributionPacket(header, bytes, ref i);
                        case 370: return new SetGroupAcceptNoticesPacket(header, bytes, ref i);
                        case 371: return new GroupRoleDataRequestPacket(header, bytes, ref i);
                        case 372: return new GroupRoleDataReplyPacket(header, bytes, ref i);
                        case 373: return new GroupRoleMembersRequestPacket(header, bytes, ref i);
                        case 374: return new GroupRoleMembersReplyPacket(header, bytes, ref i);
                        case 375: return new GroupTitlesRequestPacket(header, bytes, ref i);
                        case 376: return new GroupTitlesReplyPacket(header, bytes, ref i);
                        case 377: return new GroupTitleUpdatePacket(header, bytes, ref i);
                        case 378: return new GroupRoleUpdatePacket(header, bytes, ref i);
                        case 379: return new LiveHelpGroupRequestPacket(header, bytes, ref i);
                        case 380: return new LiveHelpGroupReplyPacket(header, bytes, ref i);
                        case 381: return new AgentWearablesRequestPacket(header, bytes, ref i);
                        case 382: return new AgentWearablesUpdatePacket(header, bytes, ref i);
                        case 383: return new AgentIsNowWearingPacket(header, bytes, ref i);
                        case 384: return new AgentCachedTexturePacket(header, bytes, ref i);
                        case 385: return new AgentCachedTextureResponsePacket(header, bytes, ref i);
                        case 386: return new AgentDataUpdateRequestPacket(header, bytes, ref i);
                        case 387: return new AgentDataUpdatePacket(header, bytes, ref i);
                        case 388: return new GroupDataUpdatePacket(header, bytes, ref i);
                        case 389: return new AgentGroupDataUpdatePacket(header, bytes, ref i);
                        case 390: return new AgentDropGroupPacket(header, bytes, ref i);
                        case 392: return new CreateTrustedCircuitPacket(header, bytes, ref i);
                        case 393: return new DenyTrustedCircuitPacket(header, bytes, ref i);
                        case 394: return new RequestTrustedCircuitPacket(header, bytes, ref i);
                        case 395: return new RezSingleAttachmentFromInvPacket(header, bytes, ref i);
                        case 396: return new RezMultipleAttachmentsFromInvPacket(header, bytes, ref i);
                        case 397: return new DetachAttachmentIntoInvPacket(header, bytes, ref i);
                        case 398: return new CreateNewOutfitAttachmentsPacket(header, bytes, ref i);
                        case 399: return new UserInfoRequestPacket(header, bytes, ref i);
                        case 400: return new UserInfoReplyPacket(header, bytes, ref i);
                        case 401: return new UpdateUserInfoPacket(header, bytes, ref i);
                        case 403: return new InitiateDownloadPacket(header, bytes, ref i);
                        case 404: return new SystemMessagePacket(header, bytes, ref i);
                        case 405: return new MapLayerRequestPacket(header, bytes, ref i);
                        case 406: return new MapLayerReplyPacket(header, bytes, ref i);
                        case 407: return new MapBlockRequestPacket(header, bytes, ref i);
                        case 408: return new MapNameRequestPacket(header, bytes, ref i);
                        case 409: return new MapBlockReplyPacket(header, bytes, ref i);
                        case 410: return new MapItemRequestPacket(header, bytes, ref i);
                        case 411: return new MapItemReplyPacket(header, bytes, ref i);
                        case 412: return new SendPostcardPacket(header, bytes, ref i);
                        case 419: return new ParcelMediaCommandMessagePacket(header, bytes, ref i);
                        case 420: return new ParcelMediaUpdatePacket(header, bytes, ref i);
                        case 421: return new LandStatRequestPacket(header, bytes, ref i);
                        case 422: return new LandStatReplyPacket(header, bytes, ref i);
                        case 423: return new ErrorPacket(header, bytes, ref i);
                        case 65531: return new PacketAckPacket(header, bytes, ref i);
                        case 65532: return new OpenCircuitPacket(header, bytes, ref i);
                        case 65533: return new CloseCircuitPacket(header, bytes, ref i);
                    }
                }
                else
                {
                    id = (ushort)bytes[7];  freq = PacketFrequency.Medium;
                    switch (id)
                    {
                        case 1: return new ObjectAddPacket(header, bytes, ref i);
                        case 2: return new MultipleObjectUpdatePacket(header, bytes, ref i);
                        case 3: return new RequestMultipleObjectsPacket(header, bytes, ref i);
                        case 4: return new ObjectPositionPacket(header, bytes, ref i);
                        case 5: return new RequestObjectPropertiesFamilyPacket(header, bytes, ref i);
                        case 6: return new CoarseLocationUpdatePacket(header, bytes, ref i);
                        case 7: return new CrossedRegionPacket(header, bytes, ref i);
                        case 8: return new ConfirmEnableSimulatorPacket(header, bytes, ref i);
                        case 9: return new ObjectPropertiesPacket(header, bytes, ref i);
                        case 10: return new ObjectPropertiesFamilyPacket(header, bytes, ref i);
                        case 11: return new ParcelPropertiesRequestPacket(header, bytes, ref i);
                        case 13: return new AttachedSoundPacket(header, bytes, ref i);
                        case 14: return new AttachedSoundGainChangePacket(header, bytes, ref i);
                        case 15: return new PreloadSoundPacket(header, bytes, ref i);
                        case 17: return new ViewerEffectPacket(header, bytes, ref i);
                    }
                }
            }
            else
            {
                id = (ushort)bytes[6];  freq = PacketFrequency.High;
                switch (id)
                    {
                        case 1: return new StartPingCheckPacket(header, bytes, ref i);
                        case 2: return new CompletePingCheckPacket(header, bytes, ref i);
                        case 4: return new AgentUpdatePacket(header, bytes, ref i);
                        case 5: return new AgentAnimationPacket(header, bytes, ref i);
                        case 6: return new AgentRequestSitPacket(header, bytes, ref i);
                        case 7: return new AgentSitPacket(header, bytes, ref i);
                        case 8: return new RequestImagePacket(header, bytes, ref i);
                        case 9: return new ImageDataPacket(header, bytes, ref i);
                        case 10: return new ImagePacketPacket(header, bytes, ref i);
                        case 11: return new LayerDataPacket(header, bytes, ref i);
                        case 12: return new ObjectUpdatePacket(header, bytes, ref i);
                        case 13: return new ObjectUpdateCompressedPacket(header, bytes, ref i);
                        case 14: return new ObjectUpdateCachedPacket(header, bytes, ref i);
                        case 15: return new ImprovedTerseObjectUpdatePacket(header, bytes, ref i);
                        case 16: return new KillObjectPacket(header, bytes, ref i);
                        case 17: return new TransferPacketPacket(header, bytes, ref i);
                        case 18: return new SendXferPacketPacket(header, bytes, ref i);
                        case 19: return new ConfirmXferPacketPacket(header, bytes, ref i);
                        case 20: return new AvatarAnimationPacket(header, bytes, ref i);
                        case 21: return new AvatarSitResponsePacket(header, bytes, ref i);
                        case 22: return new CameraConstraintPacket(header, bytes, ref i);
                        case 23: return new ParcelPropertiesPacket(header, bytes, ref i);
                        case 25: return new ChildAgentUpdatePacket(header, bytes, ref i);
                        case 26: return new ChildAgentAlivePacket(header, bytes, ref i);
                        case 27: return new ChildAgentPositionUpdatePacket(header, bytes, ref i);
                        case 29: return new SoundTriggerPacket(header, bytes, ref i);
                }
            }

            throw new MalformedDataException("Unknown packet ID "+freq+" "+id);
        }
    }

    /// <exclude/>
    public class TestMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("testmessage_testblock1")]
        public class TestBlock1Block
        {
            public uint Test1;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public TestBlock1Block() { }
            public TestBlock1Block(byte[] bytes, ref int i)
            {
                try
                {
                    Test1 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Test1 % 256);
                bytes[i++] = (byte)((Test1 >> 8) % 256);
                bytes[i++] = (byte)((Test1 >> 16) % 256);
                bytes[i++] = (byte)((Test1 >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TestBlock1 --");
                output.Append(String.Format("Test1: {0}", Test1));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("testmessage_neighborblock")]
        public class NeighborBlockBlock
        {
            public uint Test0;
            public uint Test1;
            public uint Test2;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public NeighborBlockBlock() { }
            public NeighborBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Test0 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Test1 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Test2 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Test0 % 256);
                bytes[i++] = (byte)((Test0 >> 8) % 256);
                bytes[i++] = (byte)((Test0 >> 16) % 256);
                bytes[i++] = (byte)((Test0 >> 24) % 256);
                bytes[i++] = (byte)(Test1 % 256);
                bytes[i++] = (byte)((Test1 >> 8) % 256);
                bytes[i++] = (byte)((Test1 >> 16) % 256);
                bytes[i++] = (byte)((Test1 >> 24) % 256);
                bytes[i++] = (byte)(Test2 % 256);
                bytes[i++] = (byte)((Test2 >> 8) % 256);
                bytes[i++] = (byte)((Test2 >> 16) % 256);
                bytes[i++] = (byte)((Test2 >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- NeighborBlock --");
                output.AppendLine(String.Format("Test0: {0}", Test0));
                output.AppendLine(String.Format("Test1: {0}", Test1));
                output.Append(String.Format("Test2: {0}", Test2));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TestMessage; } }
        public TestBlock1Block TestBlock1;
        public NeighborBlockBlock[] NeighborBlock;

        public TestMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 1;
            Header.Reliable = true;
            TestBlock1 = new TestBlock1Block();
            NeighborBlock = new NeighborBlockBlock[4];
        }

        public TestMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TestBlock1 = new TestBlock1Block(bytes, ref i);
            NeighborBlock = new NeighborBlockBlock[4];
            for (int j = 0; j < 4; j++)
            { NeighborBlock[j] = new NeighborBlockBlock(bytes, ref i); }
        }

        public TestMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TestBlock1 = new TestBlock1Block(bytes, ref i);
            NeighborBlock = new NeighborBlockBlock[4];
            for (int j = 0; j < 4; j++)
            { NeighborBlock[j] = new NeighborBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TestBlock1.Length;;
            for (int j = 0; j < 4; j++) { length += NeighborBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TestBlock1.ToBytes(bytes, ref i);
            for (int j = 0; j < 4; j++) { NeighborBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TestMessage ---" + Environment.NewLine;
                output += TestBlock1.ToString() + Environment.NewLine;
            for (int j = 0; j < 4; j++)
            {
                output += NeighborBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UseCircuitCodePacket : Packet
    {
        /// <exclude/>
        [XmlType("usecircuitcode_circuitcode")]
        public class CircuitCodeBlock
        {
            public uint Code;
            public LLUUID SessionID;
            public LLUUID ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public CircuitCodeBlock() { }
            public CircuitCodeBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Code = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SessionID = new LLUUID(bytes, i); i += 16;
                    ID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Code % 256);
                bytes[i++] = (byte)((Code >> 8) % 256);
                bytes[i++] = (byte)((Code >> 16) % 256);
                bytes[i++] = (byte)((Code >> 24) % 256);
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- CircuitCode --");
                output.AppendLine(String.Format("Code: {0}", Code));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UseCircuitCode; } }
        public CircuitCodeBlock CircuitCode;

        public UseCircuitCodePacket()
        {
            Header = new LowHeader();
            Header.ID = 3;
            Header.Reliable = true;
            CircuitCode = new CircuitCodeBlock();
        }

        public UseCircuitCodePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            CircuitCode = new CircuitCodeBlock(bytes, ref i);
        }

        public UseCircuitCodePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            CircuitCode = new CircuitCodeBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += CircuitCode.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            CircuitCode.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UseCircuitCode ---" + Environment.NewLine;
                output += CircuitCode.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TelehubInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("telehubinfo_telehubblock")]
        public class TelehubBlockBlock
        {
            public LLUUID ObjectID;
            private byte[] _objectname;
            public byte[] ObjectName
            {
                get { return _objectname; }
                set
                {
                    if (value == null) { _objectname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
                }
            }
            public LLVector3 TelehubPos;
            public LLQuaternion TelehubRot;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 40;
                    if (ObjectName != null) { length += 1 + ObjectName.Length; }
                    return length;
                }
            }

            public TelehubBlockBlock() { }
            public TelehubBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _objectname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
                    TelehubPos = new LLVector3(bytes, i); i += 12;
                    TelehubRot = new LLQuaternion(bytes, i, true); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectName.Length;
                Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
                Buffer.BlockCopy(TelehubPos.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(TelehubRot.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TelehubBlock --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                Helpers.FieldToString(output, ObjectName, "ObjectName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("TelehubPos: {0}", TelehubPos));
                output.Append(String.Format("TelehubRot: {0}", TelehubRot));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("telehubinfo_spawnpointblock")]
        public class SpawnPointBlockBlock
        {
            public LLVector3 SpawnPointPos;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public SpawnPointBlockBlock() { }
            public SpawnPointBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SpawnPointPos = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(SpawnPointPos.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SpawnPointBlock --");
                output.Append(String.Format("SpawnPointPos: {0}", SpawnPointPos));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TelehubInfo; } }
        public TelehubBlockBlock TelehubBlock;
        public SpawnPointBlockBlock[] SpawnPointBlock;

        public TelehubInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 10;
            Header.Reliable = true;
            TelehubBlock = new TelehubBlockBlock();
            SpawnPointBlock = new SpawnPointBlockBlock[0];
        }

        public TelehubInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TelehubBlock = new TelehubBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            SpawnPointBlock = new SpawnPointBlockBlock[count];
            for (int j = 0; j < count; j++)
            { SpawnPointBlock[j] = new SpawnPointBlockBlock(bytes, ref i); }
        }

        public TelehubInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TelehubBlock = new TelehubBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            SpawnPointBlock = new SpawnPointBlockBlock[count];
            for (int j = 0; j < count; j++)
            { SpawnPointBlock[j] = new SpawnPointBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TelehubBlock.Length;;
            length++;
            for (int j = 0; j < SpawnPointBlock.Length; j++) { length += SpawnPointBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TelehubBlock.ToBytes(bytes, ref i);
            bytes[i++] = (byte)SpawnPointBlock.Length;
            for (int j = 0; j < SpawnPointBlock.Length; j++) { SpawnPointBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TelehubInfo ---" + Environment.NewLine;
                output += TelehubBlock.ToString() + Environment.NewLine;
            for (int j = 0; j < SpawnPointBlock.Length; j++)
            {
                output += SpawnPointBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class EconomyDataRequestPacket : Packet
    {
        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EconomyDataRequest; } }

        public EconomyDataRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 24;
            Header.Reliable = true;
        }

        public EconomyDataRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
        }

        public EconomyDataRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EconomyDataRequest ---" + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EconomyDataPacket : Packet
    {
        /// <exclude/>
        [XmlType("economydata_info")]
        public class InfoBlock
        {
            public int ObjectCapacity;
            public int ObjectCount;
            public int PriceEnergyUnit;
            public int PriceObjectClaim;
            public int PricePublicObjectDecay;
            public int PricePublicObjectDelete;
            public int PriceParcelClaim;
            public float PriceParcelClaimFactor;
            public int PriceUpload;
            public int PriceRentLight;
            public int TeleportMinPrice;
            public float TeleportPriceExponent;
            public float EnergyEfficiency;
            public float PriceObjectRent;
            public float PriceObjectScaleFactor;
            public int PriceParcelRent;
            public int PriceGroupCreate;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 68;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectCapacity = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ObjectCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PriceEnergyUnit = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PriceObjectClaim = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PricePublicObjectDecay = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PricePublicObjectDelete = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PriceParcelClaim = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    PriceParcelClaimFactor = BitConverter.ToSingle(bytes, i); i += 4;
                    PriceUpload = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PriceRentLight = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TeleportMinPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TeleportPriceExponent = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    EnergyEfficiency = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    PriceObjectRent = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    PriceObjectScaleFactor = BitConverter.ToSingle(bytes, i); i += 4;
                    PriceParcelRent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PriceGroupCreate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(ObjectCapacity % 256);
                bytes[i++] = (byte)((ObjectCapacity >> 8) % 256);
                bytes[i++] = (byte)((ObjectCapacity >> 16) % 256);
                bytes[i++] = (byte)((ObjectCapacity >> 24) % 256);
                bytes[i++] = (byte)(ObjectCount % 256);
                bytes[i++] = (byte)((ObjectCount >> 8) % 256);
                bytes[i++] = (byte)((ObjectCount >> 16) % 256);
                bytes[i++] = (byte)((ObjectCount >> 24) % 256);
                bytes[i++] = (byte)(PriceEnergyUnit % 256);
                bytes[i++] = (byte)((PriceEnergyUnit >> 8) % 256);
                bytes[i++] = (byte)((PriceEnergyUnit >> 16) % 256);
                bytes[i++] = (byte)((PriceEnergyUnit >> 24) % 256);
                bytes[i++] = (byte)(PriceObjectClaim % 256);
                bytes[i++] = (byte)((PriceObjectClaim >> 8) % 256);
                bytes[i++] = (byte)((PriceObjectClaim >> 16) % 256);
                bytes[i++] = (byte)((PriceObjectClaim >> 24) % 256);
                bytes[i++] = (byte)(PricePublicObjectDecay % 256);
                bytes[i++] = (byte)((PricePublicObjectDecay >> 8) % 256);
                bytes[i++] = (byte)((PricePublicObjectDecay >> 16) % 256);
                bytes[i++] = (byte)((PricePublicObjectDecay >> 24) % 256);
                bytes[i++] = (byte)(PricePublicObjectDelete % 256);
                bytes[i++] = (byte)((PricePublicObjectDelete >> 8) % 256);
                bytes[i++] = (byte)((PricePublicObjectDelete >> 16) % 256);
                bytes[i++] = (byte)((PricePublicObjectDelete >> 24) % 256);
                bytes[i++] = (byte)(PriceParcelClaim % 256);
                bytes[i++] = (byte)((PriceParcelClaim >> 8) % 256);
                bytes[i++] = (byte)((PriceParcelClaim >> 16) % 256);
                bytes[i++] = (byte)((PriceParcelClaim >> 24) % 256);
                ba = BitConverter.GetBytes(PriceParcelClaimFactor);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(PriceUpload % 256);
                bytes[i++] = (byte)((PriceUpload >> 8) % 256);
                bytes[i++] = (byte)((PriceUpload >> 16) % 256);
                bytes[i++] = (byte)((PriceUpload >> 24) % 256);
                bytes[i++] = (byte)(PriceRentLight % 256);
                bytes[i++] = (byte)((PriceRentLight >> 8) % 256);
                bytes[i++] = (byte)((PriceRentLight >> 16) % 256);
                bytes[i++] = (byte)((PriceRentLight >> 24) % 256);
                bytes[i++] = (byte)(TeleportMinPrice % 256);
                bytes[i++] = (byte)((TeleportMinPrice >> 8) % 256);
                bytes[i++] = (byte)((TeleportMinPrice >> 16) % 256);
                bytes[i++] = (byte)((TeleportMinPrice >> 24) % 256);
                ba = BitConverter.GetBytes(TeleportPriceExponent);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(EnergyEfficiency);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(PriceObjectRent);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(PriceObjectScaleFactor);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(PriceParcelRent % 256);
                bytes[i++] = (byte)((PriceParcelRent >> 8) % 256);
                bytes[i++] = (byte)((PriceParcelRent >> 16) % 256);
                bytes[i++] = (byte)((PriceParcelRent >> 24) % 256);
                bytes[i++] = (byte)(PriceGroupCreate % 256);
                bytes[i++] = (byte)((PriceGroupCreate >> 8) % 256);
                bytes[i++] = (byte)((PriceGroupCreate >> 16) % 256);
                bytes[i++] = (byte)((PriceGroupCreate >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("ObjectCapacity: {0}", ObjectCapacity));
                output.AppendLine(String.Format("ObjectCount: {0}", ObjectCount));
                output.AppendLine(String.Format("PriceEnergyUnit: {0}", PriceEnergyUnit));
                output.AppendLine(String.Format("PriceObjectClaim: {0}", PriceObjectClaim));
                output.AppendLine(String.Format("PricePublicObjectDecay: {0}", PricePublicObjectDecay));
                output.AppendLine(String.Format("PricePublicObjectDelete: {0}", PricePublicObjectDelete));
                output.AppendLine(String.Format("PriceParcelClaim: {0}", PriceParcelClaim));
                output.AppendLine(String.Format("PriceParcelClaimFactor: {0}", PriceParcelClaimFactor));
                output.AppendLine(String.Format("PriceUpload: {0}", PriceUpload));
                output.AppendLine(String.Format("PriceRentLight: {0}", PriceRentLight));
                output.AppendLine(String.Format("TeleportMinPrice: {0}", TeleportMinPrice));
                output.AppendLine(String.Format("TeleportPriceExponent: {0}", TeleportPriceExponent));
                output.AppendLine(String.Format("EnergyEfficiency: {0}", EnergyEfficiency));
                output.AppendLine(String.Format("PriceObjectRent: {0}", PriceObjectRent));
                output.AppendLine(String.Format("PriceObjectScaleFactor: {0}", PriceObjectScaleFactor));
                output.AppendLine(String.Format("PriceParcelRent: {0}", PriceParcelRent));
                output.Append(String.Format("PriceGroupCreate: {0}", PriceGroupCreate));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EconomyData; } }
        public InfoBlock Info;

        public EconomyDataPacket()
        {
            Header = new LowHeader();
            Header.ID = 25;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public EconomyDataPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public EconomyDataPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EconomyData ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarPickerRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarpickerrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarpickerrequest_data")]
        public class DataBlock
        {
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarPickerRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public AvatarPickerRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 26;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public AvatarPickerRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public AvatarPickerRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarPickerRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarPickerReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarpickerreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarpickerreply_data")]
        public class DataBlock
        {
            public LLUUID AvatarID;
            private byte[] _firstname;
            public byte[] FirstName
            {
                get { return _firstname; }
                set
                {
                    if (value == null) { _firstname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
                }
            }
            private byte[] _lastname;
            public byte[] LastName
            {
                get { return _lastname; }
                set
                {
                    if (value == null) { _lastname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (FirstName != null) { length += 1 + FirstName.Length; }
                    if (LastName != null) { length += 1 + LastName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AvatarID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _firstname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _lastname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FirstName.Length;
                Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
                if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
                bytes[i++] = (byte)LastName.Length;
                Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("AvatarID: {0}", AvatarID));
                Helpers.FieldToString(output, FirstName, "FirstName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LastName, "LastName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarPickerReply; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public AvatarPickerReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 28;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public AvatarPickerReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public AvatarPickerReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarPickerReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class PlacesQueryPacket : Packet
    {
        /// <exclude/>
        [XmlType("placesquery_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("placesquery_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("placesquery_querydata")]
        public class QueryDataBlock
        {
            private byte[] _querytext;
            public byte[] QueryText
            {
                get { return _querytext; }
                set
                {
                    if (value == null) { _querytext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
                }
            }
            public uint QueryFlags;
            public sbyte Category;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 5;
                    if (QueryText != null) { length += 1 + QueryText.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _querytext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Category = (sbyte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
                bytes[i++] = (byte)QueryText.Length;
                Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
                bytes[i++] = (byte)Category;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                Helpers.FieldToString(output, QueryText, "QueryText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
                output.AppendLine(String.Format("Category: {0}", Category));
                Helpers.FieldToString(output, SimName, "SimName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PlacesQuery; } }
        public AgentDataBlock AgentData;
        public TransactionDataBlock TransactionData;
        public QueryDataBlock QueryData;

        public PlacesQueryPacket()
        {
            Header = new LowHeader();
            Header.ID = 29;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionData = new TransactionDataBlock();
            QueryData = new QueryDataBlock();
        }

        public PlacesQueryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public PlacesQueryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PlacesQuery ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PlacesReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("placesreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("placesreply_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("placesreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID OwnerID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            public int ActualArea;
            public int BillableArea;
            public byte Flags;
            public float GlobalX;
            public float GlobalY;
            public float GlobalZ;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLUUID SnapshotID;
            public float Dwell;
            public int Price;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 61;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 1 + Desc.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    ActualArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    BillableArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    GlobalX = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    GlobalY = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    GlobalZ = BitConverter.ToSingle(bytes, i); i += 4;
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Dwell = BitConverter.ToSingle(bytes, i); i += 4;
                    Price = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)Desc.Length;
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                bytes[i++] = (byte)(ActualArea % 256);
                bytes[i++] = (byte)((ActualArea >> 8) % 256);
                bytes[i++] = (byte)((ActualArea >> 16) % 256);
                bytes[i++] = (byte)((ActualArea >> 24) % 256);
                bytes[i++] = (byte)(BillableArea % 256);
                bytes[i++] = (byte)((BillableArea >> 8) % 256);
                bytes[i++] = (byte)((BillableArea >> 16) % 256);
                bytes[i++] = (byte)((BillableArea >> 24) % 256);
                bytes[i++] = Flags;
                ba = BitConverter.GetBytes(GlobalX);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(GlobalY);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(GlobalZ);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(Dwell);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(Price % 256);
                bytes[i++] = (byte)((Price >> 8) % 256);
                bytes[i++] = (byte)((Price >> 16) % 256);
                bytes[i++] = (byte)((Price >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ActualArea: {0}", ActualArea));
                output.AppendLine(String.Format("BillableArea: {0}", BillableArea));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("GlobalX: {0}", GlobalX));
                output.AppendLine(String.Format("GlobalY: {0}", GlobalY));
                output.AppendLine(String.Format("GlobalZ: {0}", GlobalZ));
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                output.AppendLine(String.Format("Dwell: {0}", Dwell));
                output.Append(String.Format("Price: {0}", Price));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PlacesReply; } }
        public AgentDataBlock AgentData;
        public TransactionDataBlock TransactionData;
        public QueryDataBlock[] QueryData;

        public PlacesReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 30;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionData = new TransactionDataBlock();
            QueryData = new QueryDataBlock[0];
        }

        public PlacesReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryData = new QueryDataBlock[count];
            for (int j = 0; j < count; j++)
            { QueryData[j] = new QueryDataBlock(bytes, ref i); }
        }

        public PlacesReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryData = new QueryDataBlock[count];
            for (int j = 0; j < count; j++)
            { QueryData[j] = new QueryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionData.Length;;
            length++;
            for (int j = 0; j < QueryData.Length; j++) { length += QueryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryData.Length;
            for (int j = 0; j < QueryData.Length; j++) { QueryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PlacesReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryData.Length; j++)
            {
                output += QueryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DirFindQueryPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirfindquery_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirfindquery_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            private byte[] _querytext;
            public byte[] QueryText
            {
                get { return _querytext; }
                set
                {
                    if (value == null) { _querytext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
                }
            }
            public uint QueryFlags;
            public int QueryStart;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (QueryText != null) { length += 1 + QueryText.Length; }
                    return length;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _querytext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
                bytes[i++] = (byte)QueryText.Length;
                Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
                bytes[i++] = (byte)(QueryStart % 256);
                bytes[i++] = (byte)((QueryStart >> 8) % 256);
                bytes[i++] = (byte)((QueryStart >> 16) % 256);
                bytes[i++] = (byte)((QueryStart >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                Helpers.FieldToString(output, QueryText, "QueryText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
                output.Append(String.Format("QueryStart: {0}", QueryStart));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirFindQuery; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;

        public DirFindQueryPacket()
        {
            Header = new LowHeader();
            Header.ID = 31;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
        }

        public DirFindQueryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public DirFindQueryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirFindQuery ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DirPlacesQueryPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirplacesquery_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirplacesquery_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            private byte[] _querytext;
            public byte[] QueryText
            {
                get { return _querytext; }
                set
                {
                    if (value == null) { _querytext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
                }
            }
            public uint QueryFlags;
            public sbyte Category;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public int QueryStart;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 25;
                    if (QueryText != null) { length += 1 + QueryText.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _querytext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Category = (sbyte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
                bytes[i++] = (byte)QueryText.Length;
                Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
                bytes[i++] = (byte)Category;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                bytes[i++] = (byte)(QueryStart % 256);
                bytes[i++] = (byte)((QueryStart >> 8) % 256);
                bytes[i++] = (byte)((QueryStart >> 16) % 256);
                bytes[i++] = (byte)((QueryStart >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                Helpers.FieldToString(output, QueryText, "QueryText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
                output.AppendLine(String.Format("Category: {0}", Category));
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.Append(String.Format("QueryStart: {0}", QueryStart));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirPlacesQuery; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;

        public DirPlacesQueryPacket()
        {
            Header = new LowHeader();
            Header.ID = 33;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
        }

        public DirPlacesQueryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public DirPlacesQueryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirPlacesQuery ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DirPlacesReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirplacesreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirplacesreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirplacesreply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID ParcelID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public bool ForSale;
            public bool Auction;
            public float Dwell;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 22;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    ForSale = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Auction = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Dwell = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                bytes[i++] = (byte)((ForSale) ? 1 : 0);
                bytes[i++] = (byte)((Auction) ? 1 : 0);
                ba = BitConverter.GetBytes(Dwell);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ForSale: {0}", ForSale));
                output.AppendLine(String.Format("Auction: {0}", Auction));
                output.Append(String.Format("Dwell: {0}", Dwell));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirPlacesReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock[] QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirPlacesReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 35;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock[0];
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirPlacesReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryData = new QueryDataBlock[count];
            for (int j = 0; j < count; j++)
            { QueryData[j] = new QueryDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirPlacesReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryData = new QueryDataBlock[count];
            for (int j = 0; j < count; j++)
            { QueryData[j] = new QueryDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < QueryData.Length; j++) { length += QueryData[j].Length; }
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryData.Length;
            for (int j = 0; j < QueryData.Length; j++) { QueryData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirPlacesReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryData.Length; j++)
            {
                output += QueryData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DirPeopleReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirpeoplereply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirpeoplereply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirpeoplereply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID AgentID;
            private byte[] _firstname;
            public byte[] FirstName
            {
                get { return _firstname; }
                set
                {
                    if (value == null) { _firstname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
                }
            }
            private byte[] _lastname;
            public byte[] LastName
            {
                get { return _lastname; }
                set
                {
                    if (value == null) { _lastname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
                }
            }
            private byte[] _group;
            public byte[] Group
            {
                get { return _group; }
                set
                {
                    if (value == null) { _group = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _group = new byte[value.Length]; Buffer.BlockCopy(value, 0, _group, 0, value.Length); }
                }
            }
            public bool Online;
            public int Reputation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 21;
                    if (FirstName != null) { length += 1 + FirstName.Length; }
                    if (LastName != null) { length += 1 + LastName.Length; }
                    if (Group != null) { length += 1 + Group.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _firstname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _lastname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _group = new byte[length];
                    Buffer.BlockCopy(bytes, i, _group, 0, length); i += length;
                    Online = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Reputation = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FirstName.Length;
                Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
                if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
                bytes[i++] = (byte)LastName.Length;
                Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
                if(Group == null) { Console.WriteLine("Warning: Group is null, in " + this.GetType()); }
                bytes[i++] = (byte)Group.Length;
                Buffer.BlockCopy(Group, 0, bytes, i, Group.Length); i += Group.Length;
                bytes[i++] = (byte)((Online) ? 1 : 0);
                bytes[i++] = (byte)(Reputation % 256);
                bytes[i++] = (byte)((Reputation >> 8) % 256);
                bytes[i++] = (byte)((Reputation >> 16) % 256);
                bytes[i++] = (byte)((Reputation >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                Helpers.FieldToString(output, FirstName, "FirstName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LastName, "LastName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Group, "Group");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Online: {0}", Online));
                output.Append(String.Format("Reputation: {0}", Reputation));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirPeopleReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirPeopleReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 36;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirPeopleReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirPeopleReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirPeopleReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DirEventsReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("direventsreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("direventsreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("direventsreply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID OwnerID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public uint EventID;
            private byte[] _date;
            public byte[] Date
            {
                get { return _date; }
                set
                {
                    if (value == null) { _date = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _date = new byte[value.Length]; Buffer.BlockCopy(value, 0, _date, 0, value.Length); }
                }
            }
            public uint UnixTime;
            public uint EventFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Date != null) { length += 1 + Date.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _date = new byte[length];
                    Buffer.BlockCopy(bytes, i, _date, 0, length); i += length;
                    UnixTime = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EventFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
                if(Date == null) { Console.WriteLine("Warning: Date is null, in " + this.GetType()); }
                bytes[i++] = (byte)Date.Length;
                Buffer.BlockCopy(Date, 0, bytes, i, Date.Length); i += Date.Length;
                bytes[i++] = (byte)(UnixTime % 256);
                bytes[i++] = (byte)((UnixTime >> 8) % 256);
                bytes[i++] = (byte)((UnixTime >> 16) % 256);
                bytes[i++] = (byte)((UnixTime >> 24) % 256);
                bytes[i++] = (byte)(EventFlags % 256);
                bytes[i++] = (byte)((EventFlags >> 8) % 256);
                bytes[i++] = (byte)((EventFlags >> 16) % 256);
                bytes[i++] = (byte)((EventFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("EventID: {0}", EventID));
                Helpers.FieldToString(output, Date, "Date");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("UnixTime: {0}", UnixTime));
                output.Append(String.Format("EventFlags: {0}", EventFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirEventsReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirEventsReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 37;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirEventsReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirEventsReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirEventsReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DirGroupsReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirgroupsreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirgroupsreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirgroupsreply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID GroupID;
            private byte[] _groupname;
            public byte[] GroupName
            {
                get { return _groupname; }
                set
                {
                    if (value == null) { _groupname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
                }
            }
            public int Members;
            public float SearchOrder;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (GroupName != null) { length += 1 + GroupName.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _groupname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
                    Members = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    SearchOrder = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupName.Length;
                Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
                bytes[i++] = (byte)(Members % 256);
                bytes[i++] = (byte)((Members >> 8) % 256);
                bytes[i++] = (byte)((Members >> 16) % 256);
                bytes[i++] = (byte)((Members >> 24) % 256);
                ba = BitConverter.GetBytes(SearchOrder);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                Helpers.FieldToString(output, GroupName, "GroupName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Members: {0}", Members));
                output.Append(String.Format("SearchOrder: {0}", SearchOrder));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirGroupsReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirGroupsReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 38;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirGroupsReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirGroupsReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirGroupsReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DirClassifiedQueryPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirclassifiedquery_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirclassifiedquery_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            private byte[] _querytext;
            public byte[] QueryText
            {
                get { return _querytext; }
                set
                {
                    if (value == null) { _querytext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
                }
            }
            public uint QueryFlags;
            public uint Category;
            public int QueryStart;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (QueryText != null) { length += 1 + QueryText.Length; }
                    return length;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _querytext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
                bytes[i++] = (byte)QueryText.Length;
                Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
                bytes[i++] = (byte)(Category % 256);
                bytes[i++] = (byte)((Category >> 8) % 256);
                bytes[i++] = (byte)((Category >> 16) % 256);
                bytes[i++] = (byte)((Category >> 24) % 256);
                bytes[i++] = (byte)(QueryStart % 256);
                bytes[i++] = (byte)((QueryStart >> 8) % 256);
                bytes[i++] = (byte)((QueryStart >> 16) % 256);
                bytes[i++] = (byte)((QueryStart >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                Helpers.FieldToString(output, QueryText, "QueryText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
                output.AppendLine(String.Format("Category: {0}", Category));
                output.Append(String.Format("QueryStart: {0}", QueryStart));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirClassifiedQuery; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;

        public DirClassifiedQueryPacket()
        {
            Header = new LowHeader();
            Header.ID = 39;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
        }

        public DirClassifiedQueryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public DirClassifiedQueryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirClassifiedQuery ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DirClassifiedReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirclassifiedreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirclassifiedreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirclassifiedreply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID ClassifiedID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public byte ClassifiedFlags;
            public uint CreationDate;
            public uint ExpirationDate;
            public int PriceForListing;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 29;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    ClassifiedFlags = (byte)bytes[i++];
                    CreationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ExpirationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PriceForListing = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                bytes[i++] = ClassifiedFlags;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(ExpirationDate % 256);
                bytes[i++] = (byte)((ExpirationDate >> 8) % 256);
                bytes[i++] = (byte)((ExpirationDate >> 16) % 256);
                bytes[i++] = (byte)((ExpirationDate >> 24) % 256);
                bytes[i++] = (byte)(PriceForListing % 256);
                bytes[i++] = (byte)((PriceForListing >> 8) % 256);
                bytes[i++] = (byte)((PriceForListing >> 16) % 256);
                bytes[i++] = (byte)((PriceForListing >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ClassifiedFlags: {0}", ClassifiedFlags));
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.AppendLine(String.Format("ExpirationDate: {0}", ExpirationDate));
                output.Append(String.Format("PriceForListing: {0}", PriceForListing));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirClassifiedReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirClassifiedReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 41;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirClassifiedReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirClassifiedReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirClassifiedReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AvatarClassifiedReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarclassifiedreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID TargetID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    TargetID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("TargetID: {0}", TargetID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarclassifiedreply_data")]
        public class DataBlock
        {
            public LLUUID ClassifiedID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarClassifiedReply; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public AvatarClassifiedReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 42;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public AvatarClassifiedReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public AvatarClassifiedReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarClassifiedReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ClassifiedInfoRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("classifiedinforequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("classifiedinforequest_data")]
        public class DataBlock
        {
            public LLUUID ClassifiedID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("ClassifiedID: {0}", ClassifiedID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ClassifiedInfoRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ClassifiedInfoRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 43;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ClassifiedInfoRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ClassifiedInfoRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ClassifiedInfoRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ClassifiedInfoReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("classifiedinforeply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("classifiedinforeply_data")]
        public class DataBlock
        {
            public LLUUID ClassifiedID;
            public LLUUID CreatorID;
            public uint CreationDate;
            public uint ExpirationDate;
            public uint Category;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            public LLUUID ParcelID;
            public uint ParentEstate;
            public LLUUID SnapshotID;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLVector3d PosGlobal;
            private byte[] _parcelname;
            public byte[] ParcelName
            {
                get { return _parcelname; }
                set
                {
                    if (value == null) { _parcelname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _parcelname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parcelname, 0, value.Length); }
                }
            }
            public byte ClassifiedFlags;
            public int PriceForListing;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 109;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 2 + Desc.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    if (ParcelName != null) { length += 1 + ParcelName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    CreationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ExpirationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    ParentEstate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    PosGlobal = new LLVector3d(bytes, i); i += 24;
                    length = (ushort)bytes[i++];
                    _parcelname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _parcelname, 0, length); i += length;
                    ClassifiedFlags = (byte)bytes[i++];
                    PriceForListing = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(ExpirationDate % 256);
                bytes[i++] = (byte)((ExpirationDate >> 8) % 256);
                bytes[i++] = (byte)((ExpirationDate >> 16) % 256);
                bytes[i++] = (byte)((ExpirationDate >> 24) % 256);
                bytes[i++] = (byte)(Category % 256);
                bytes[i++] = (byte)((Category >> 8) % 256);
                bytes[i++] = (byte)((Category >> 16) % 256);
                bytes[i++] = (byte)((Category >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Desc.Length % 256);
                bytes[i++] = (byte)((Desc.Length >> 8) % 256);
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ParentEstate % 256);
                bytes[i++] = (byte)((ParentEstate >> 8) % 256);
                bytes[i++] = (byte)((ParentEstate >> 16) % 256);
                bytes[i++] = (byte)((ParentEstate >> 24) % 256);
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
                if(ParcelName == null) { Console.WriteLine("Warning: ParcelName is null, in " + this.GetType()); }
                bytes[i++] = (byte)ParcelName.Length;
                Buffer.BlockCopy(ParcelName, 0, bytes, i, ParcelName.Length); i += ParcelName.Length;
                bytes[i++] = ClassifiedFlags;
                bytes[i++] = (byte)(PriceForListing % 256);
                bytes[i++] = (byte)((PriceForListing >> 8) % 256);
                bytes[i++] = (byte)((PriceForListing >> 16) % 256);
                bytes[i++] = (byte)((PriceForListing >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.AppendLine(String.Format("ExpirationDate: {0}", ExpirationDate));
                output.AppendLine(String.Format("Category: {0}", Category));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                output.AppendLine(String.Format("ParentEstate: {0}", ParentEstate));
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
                Helpers.FieldToString(output, ParcelName, "ParcelName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ClassifiedFlags: {0}", ClassifiedFlags));
                output.Append(String.Format("PriceForListing: {0}", PriceForListing));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ClassifiedInfoReply; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ClassifiedInfoReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 44;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ClassifiedInfoReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ClassifiedInfoReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ClassifiedInfoReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ClassifiedInfoUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("classifiedinfoupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("classifiedinfoupdate_data")]
        public class DataBlock
        {
            public LLUUID ClassifiedID;
            public uint Category;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            public LLUUID ParcelID;
            public uint ParentEstate;
            public LLUUID SnapshotID;
            public LLVector3d PosGlobal;
            public byte ClassifiedFlags;
            public int PriceForListing;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 85;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 2 + Desc.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                    Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    ParentEstate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    PosGlobal = new LLVector3d(bytes, i); i += 24;
                    ClassifiedFlags = (byte)bytes[i++];
                    PriceForListing = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Category % 256);
                bytes[i++] = (byte)((Category >> 8) % 256);
                bytes[i++] = (byte)((Category >> 16) % 256);
                bytes[i++] = (byte)((Category >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Desc.Length % 256);
                bytes[i++] = (byte)((Desc.Length >> 8) % 256);
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ParentEstate % 256);
                bytes[i++] = (byte)((ParentEstate >> 8) % 256);
                bytes[i++] = (byte)((ParentEstate >> 16) % 256);
                bytes[i++] = (byte)((ParentEstate >> 24) % 256);
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
                bytes[i++] = ClassifiedFlags;
                bytes[i++] = (byte)(PriceForListing % 256);
                bytes[i++] = (byte)((PriceForListing >> 8) % 256);
                bytes[i++] = (byte)((PriceForListing >> 16) % 256);
                bytes[i++] = (byte)((PriceForListing >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
                output.AppendLine(String.Format("Category: {0}", Category));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                output.AppendLine(String.Format("ParentEstate: {0}", ParentEstate));
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
                output.AppendLine(String.Format("ClassifiedFlags: {0}", ClassifiedFlags));
                output.Append(String.Format("PriceForListing: {0}", PriceForListing));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ClassifiedInfoUpdate; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ClassifiedInfoUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 45;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ClassifiedInfoUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ClassifiedInfoUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ClassifiedInfoUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ClassifiedDeletePacket : Packet
    {
        /// <exclude/>
        [XmlType("classifieddelete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("classifieddelete_data")]
        public class DataBlock
        {
            public LLUUID ClassifiedID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("ClassifiedID: {0}", ClassifiedID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ClassifiedDelete; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ClassifiedDeletePacket()
        {
            Header = new LowHeader();
            Header.ID = 46;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ClassifiedDeletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ClassifiedDeletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ClassifiedDelete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ClassifiedGodDeletePacket : Packet
    {
        /// <exclude/>
        [XmlType("classifiedgoddelete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("classifiedgoddelete_data")]
        public class DataBlock
        {
            public LLUUID ClassifiedID;
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ClassifiedID = new LLUUID(bytes, i); i += 16;
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ClassifiedGodDelete; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ClassifiedGodDeletePacket()
        {
            Header = new LowHeader();
            Header.ID = 47;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ClassifiedGodDeletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ClassifiedGodDeletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ClassifiedGodDelete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DirLandQueryPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirlandquery_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirlandquery_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            public uint QueryFlags;
            public uint SearchType;
            public int Price;
            public int Area;
            public int QueryStart;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SearchType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Price = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Area = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
                bytes[i++] = (byte)(SearchType % 256);
                bytes[i++] = (byte)((SearchType >> 8) % 256);
                bytes[i++] = (byte)((SearchType >> 16) % 256);
                bytes[i++] = (byte)((SearchType >> 24) % 256);
                bytes[i++] = (byte)(Price % 256);
                bytes[i++] = (byte)((Price >> 8) % 256);
                bytes[i++] = (byte)((Price >> 16) % 256);
                bytes[i++] = (byte)((Price >> 24) % 256);
                bytes[i++] = (byte)(Area % 256);
                bytes[i++] = (byte)((Area >> 8) % 256);
                bytes[i++] = (byte)((Area >> 16) % 256);
                bytes[i++] = (byte)((Area >> 24) % 256);
                bytes[i++] = (byte)(QueryStart % 256);
                bytes[i++] = (byte)((QueryStart >> 8) % 256);
                bytes[i++] = (byte)((QueryStart >> 16) % 256);
                bytes[i++] = (byte)((QueryStart >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
                output.AppendLine(String.Format("SearchType: {0}", SearchType));
                output.AppendLine(String.Format("Price: {0}", Price));
                output.AppendLine(String.Format("Area: {0}", Area));
                output.Append(String.Format("QueryStart: {0}", QueryStart));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirLandQuery; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;

        public DirLandQueryPacket()
        {
            Header = new LowHeader();
            Header.ID = 48;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
        }

        public DirLandQueryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public DirLandQueryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirLandQuery ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DirLandReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirlandreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirlandreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirlandreply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID ParcelID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public bool Auction;
            public bool ForSale;
            public int SalePrice;
            public int ActualArea;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 26;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    Auction = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ForSale = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ActualArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                bytes[i++] = (byte)((Auction) ? 1 : 0);
                bytes[i++] = (byte)((ForSale) ? 1 : 0);
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                bytes[i++] = (byte)(ActualArea % 256);
                bytes[i++] = (byte)((ActualArea >> 8) % 256);
                bytes[i++] = (byte)((ActualArea >> 16) % 256);
                bytes[i++] = (byte)((ActualArea >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Auction: {0}", Auction));
                output.AppendLine(String.Format("ForSale: {0}", ForSale));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                output.Append(String.Format("ActualArea: {0}", ActualArea));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirLandReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirLandReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 50;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirLandReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirLandReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirLandReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DirPopularQueryPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirpopularquery_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirpopularquery_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            public uint QueryFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                output.Append(String.Format("QueryFlags: {0}", QueryFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirPopularQuery; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;

        public DirPopularQueryPacket()
        {
            Header = new LowHeader();
            Header.ID = 51;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
        }

        public DirPopularQueryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public DirPopularQueryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirPopularQuery ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DirPopularReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("dirpopularreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirpopularreply_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("dirpopularreply_queryreplies")]
        public class QueryRepliesBlock
        {
            public LLUUID ParcelID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public float Dwell;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 20;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public QueryRepliesBlock() { }
            public QueryRepliesBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Dwell = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                ba = BitConverter.GetBytes(Dwell);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryReplies --");
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Dwell: {0}", Dwell));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DirPopularReply; } }
        public AgentDataBlock AgentData;
        public QueryDataBlock QueryData;
        public QueryRepliesBlock[] QueryReplies;

        public DirPopularReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 53;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            QueryData = new QueryDataBlock();
            QueryReplies = new QueryRepliesBlock[0];
        }

        public DirPopularReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public DirPopularReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            QueryReplies = new QueryRepliesBlock[count];
            for (int j = 0; j < count; j++)
            { QueryReplies[j] = new QueryRepliesBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += QueryData.Length;;
            length++;
            for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)QueryReplies.Length;
            for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DirPopularReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            for (int j = 0; j < QueryReplies.Length; j++)
            {
                output += QueryReplies[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelInfoRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelinforequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelinforequest_data")]
        public class DataBlock
        {
            public LLUUID ParcelID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ParcelID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("ParcelID: {0}", ParcelID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelInfoRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelInfoRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 54;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelInfoRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelInfoRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelInfoRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelInfoReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelinforeply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelinforeply_data")]
        public class DataBlock
        {
            public LLUUID ParcelID;
            public LLUUID OwnerID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            public int ActualArea;
            public int BillableArea;
            public byte Flags;
            public float GlobalX;
            public float GlobalY;
            public float GlobalZ;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLUUID SnapshotID;
            public float Dwell;
            public int SalePrice;
            public int AuctionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 81;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 1 + Desc.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    ActualArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    BillableArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    GlobalX = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    GlobalY = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    GlobalZ = BitConverter.ToSingle(bytes, i); i += 4;
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Dwell = BitConverter.ToSingle(bytes, i); i += 4;
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AuctionID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)Desc.Length;
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                bytes[i++] = (byte)(ActualArea % 256);
                bytes[i++] = (byte)((ActualArea >> 8) % 256);
                bytes[i++] = (byte)((ActualArea >> 16) % 256);
                bytes[i++] = (byte)((ActualArea >> 24) % 256);
                bytes[i++] = (byte)(BillableArea % 256);
                bytes[i++] = (byte)((BillableArea >> 8) % 256);
                bytes[i++] = (byte)((BillableArea >> 16) % 256);
                bytes[i++] = (byte)((BillableArea >> 24) % 256);
                bytes[i++] = Flags;
                ba = BitConverter.GetBytes(GlobalX);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(GlobalY);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(GlobalZ);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(Dwell);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                bytes[i++] = (byte)(AuctionID % 256);
                bytes[i++] = (byte)((AuctionID >> 8) % 256);
                bytes[i++] = (byte)((AuctionID >> 16) % 256);
                bytes[i++] = (byte)((AuctionID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ActualArea: {0}", ActualArea));
                output.AppendLine(String.Format("BillableArea: {0}", BillableArea));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("GlobalX: {0}", GlobalX));
                output.AppendLine(String.Format("GlobalY: {0}", GlobalY));
                output.AppendLine(String.Format("GlobalZ: {0}", GlobalZ));
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                output.AppendLine(String.Format("Dwell: {0}", Dwell));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                output.Append(String.Format("AuctionID: {0}", AuctionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelInfoReply; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelInfoReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 55;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelInfoReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelInfoReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelInfoReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelObjectOwnersRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelobjectownersrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelobjectownersrequest_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelObjectOwnersRequest; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelObjectOwnersRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 56;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelObjectOwnersRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelObjectOwnersRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelObjectOwnersRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelObjectOwnersReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelobjectownersreply_data")]
        public class DataBlock
        {
            public LLUUID OwnerID;
            public bool IsGroupOwned;
            public int Count;
            public bool OnlineStatus;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 22;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Count = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OnlineStatus = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
                bytes[i++] = (byte)(Count % 256);
                bytes[i++] = (byte)((Count >> 8) % 256);
                bytes[i++] = (byte)((Count >> 16) % 256);
                bytes[i++] = (byte)((Count >> 24) % 256);
                bytes[i++] = (byte)((OnlineStatus) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
                output.AppendLine(String.Format("Count: {0}", Count));
                output.Append(String.Format("OnlineStatus: {0}", OnlineStatus));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelObjectOwnersReply; } }
        public DataBlock[] Data;

        public ParcelObjectOwnersReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 57;
            Header.Reliable = true;
            Data = new DataBlock[0];
        }

        public ParcelObjectOwnersReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public ParcelObjectOwnersReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelObjectOwnersReply ---" + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupNoticesListRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupnoticeslistrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupnoticeslistrequest_data")]
        public class DataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupNoticesListRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public GroupNoticesListRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 58;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public GroupNoticesListRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public GroupNoticesListRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupNoticesListRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupNoticesListReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupnoticeslistreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupnoticeslistreply_data")]
        public class DataBlock
        {
            public LLUUID NoticeID;
            public uint Timestamp;
            private byte[] _fromname;
            public byte[] FromName
            {
                get { return _fromname; }
                set
                {
                    if (value == null) { _fromname = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _fromname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _fromname, 0, value.Length); }
                }
            }
            private byte[] _subject;
            public byte[] Subject
            {
                get { return _subject; }
                set
                {
                    if (value == null) { _subject = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _subject = new byte[value.Length]; Buffer.BlockCopy(value, 0, _subject, 0, value.Length); }
                }
            }
            public bool HasAttachment;
            public byte AssetType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 22;
                    if (FromName != null) { length += 2 + FromName.Length; }
                    if (Subject != null) { length += 2 + Subject.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    NoticeID = new LLUUID(bytes, i); i += 16;
                    Timestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _fromname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _fromname, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _subject = new byte[length];
                    Buffer.BlockCopy(bytes, i, _subject, 0, length); i += length;
                    HasAttachment = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AssetType = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(NoticeID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Timestamp % 256);
                bytes[i++] = (byte)((Timestamp >> 8) % 256);
                bytes[i++] = (byte)((Timestamp >> 16) % 256);
                bytes[i++] = (byte)((Timestamp >> 24) % 256);
                if(FromName == null) { Console.WriteLine("Warning: FromName is null, in " + this.GetType()); }
                bytes[i++] = (byte)(FromName.Length % 256);
                bytes[i++] = (byte)((FromName.Length >> 8) % 256);
                Buffer.BlockCopy(FromName, 0, bytes, i, FromName.Length); i += FromName.Length;
                if(Subject == null) { Console.WriteLine("Warning: Subject is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Subject.Length % 256);
                bytes[i++] = (byte)((Subject.Length >> 8) % 256);
                Buffer.BlockCopy(Subject, 0, bytes, i, Subject.Length); i += Subject.Length;
                bytes[i++] = (byte)((HasAttachment) ? 1 : 0);
                bytes[i++] = AssetType;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("NoticeID: {0}", NoticeID));
                output.AppendLine(String.Format("Timestamp: {0}", Timestamp));
                Helpers.FieldToString(output, FromName, "FromName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Subject, "Subject");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("HasAttachment: {0}", HasAttachment));
                output.Append(String.Format("AssetType: {0}", AssetType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupNoticesListReply; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public GroupNoticesListReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 59;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public GroupNoticesListReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public GroupNoticesListReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupNoticesListReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupNoticeRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupnoticerequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupnoticerequest_data")]
        public class DataBlock
        {
            public LLUUID GroupNoticeID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupNoticeID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupNoticeID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("GroupNoticeID: {0}", GroupNoticeID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupNoticeRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public GroupNoticeRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 60;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public GroupNoticeRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public GroupNoticeRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupNoticeRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("teleportrequest_info")]
        public class InfoBlock
        {
            public LLUUID RegionID;
            public LLVector3 Position;
            public LLVector3 LookAt;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 40;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionID = new LLUUID(bytes, i); i += 16;
                    Position = new LLVector3(bytes, i); i += 12;
                    LookAt = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("RegionID: {0}", RegionID));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.Append(String.Format("LookAt: {0}", LookAt));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportRequest; } }
        public AgentDataBlock AgentData;
        public InfoBlock Info;

        public TeleportRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 62;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Info = new InfoBlock();
        }

        public TeleportRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportLocationRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportlocationrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("teleportlocationrequest_info")]
        public class InfoBlock
        {
            public ulong RegionHandle;
            public LLVector3 Position;
            public LLVector3 LookAt;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Position = new LLVector3(bytes, i); i += 12;
                    LookAt = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.Append(String.Format("LookAt: {0}", LookAt));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportLocationRequest; } }
        public AgentDataBlock AgentData;
        public InfoBlock Info;

        public TeleportLocationRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 63;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Info = new InfoBlock();
        }

        public TeleportLocationRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportLocationRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportLocationRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportLocalPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportlocal_info")]
        public class InfoBlock
        {
            public LLUUID AgentID;
            public uint LocationID;
            public LLVector3 Position;
            public LLVector3 LookAt;
            public uint TeleportFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    LocationID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Position = new LLVector3(bytes, i); i += 12;
                    LookAt = new LLVector3(bytes, i); i += 12;
                    TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(LocationID % 256);
                bytes[i++] = (byte)((LocationID >> 8) % 256);
                bytes[i++] = (byte)((LocationID >> 16) % 256);
                bytes[i++] = (byte)((LocationID >> 24) % 256);
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)(TeleportFlags % 256);
                bytes[i++] = (byte)((TeleportFlags >> 8) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 16) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("LocationID: {0}", LocationID));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.AppendLine(String.Format("LookAt: {0}", LookAt));
                output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportLocal; } }
        public InfoBlock Info;

        public TeleportLocalPacket()
        {
            Header = new LowHeader();
            Header.ID = 64;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportLocalPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportLocalPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportLocal ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportLandmarkRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportlandmarkrequest_info")]
        public class InfoBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID LandmarkID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    LandmarkID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(LandmarkID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("LandmarkID: {0}", LandmarkID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportLandmarkRequest; } }
        public InfoBlock Info;

        public TeleportLandmarkRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 65;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportLandmarkRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportLandmarkRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportLandmarkRequest ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportProgressPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportprogress_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("teleportprogress_info")]
        public class InfoBlock
        {
            public uint TeleportFlags;
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Message != null) { length += 1 + Message.Length; }
                    return length;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(TeleportFlags % 256);
                bytes[i++] = (byte)((TeleportFlags >> 8) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 16) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 24) % 256);
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)Message.Length;
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("TeleportFlags: {0}", TeleportFlags));
                Helpers.FieldToString(output, Message, "Message");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportProgress; } }
        public AgentDataBlock AgentData;
        public InfoBlock Info;

        public TeleportProgressPacket()
        {
            Header = new LowHeader();
            Header.ID = 66;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Info = new InfoBlock();
        }

        public TeleportProgressPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportProgressPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportProgress ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportFinishPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportfinish_info")]
        public class InfoBlock
        {
            public LLUUID AgentID;
            public uint LocationID;
            public uint SimIP;
            public ushort SimPort;
            public ulong RegionHandle;
            private byte[] _seedcapability;
            public byte[] SeedCapability
            {
                get { return _seedcapability; }
                set
                {
                    if (value == null) { _seedcapability = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _seedcapability = new byte[value.Length]; Buffer.BlockCopy(value, 0, _seedcapability, 0, value.Length); }
                }
            }
            public byte SimAccess;
            public uint TeleportFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 39;
                    if (SeedCapability != null) { length += 2 + SeedCapability.Length; }
                    return length;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    LocationID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SimIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SimPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _seedcapability = new byte[length];
                    Buffer.BlockCopy(bytes, i, _seedcapability, 0, length); i += length;
                    SimAccess = (byte)bytes[i++];
                    TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(LocationID % 256);
                bytes[i++] = (byte)((LocationID >> 8) % 256);
                bytes[i++] = (byte)((LocationID >> 16) % 256);
                bytes[i++] = (byte)((LocationID >> 24) % 256);
                bytes[i++] = (byte)(SimIP % 256);
                bytes[i++] = (byte)((SimIP >> 8) % 256);
                bytes[i++] = (byte)((SimIP >> 16) % 256);
                bytes[i++] = (byte)((SimIP >> 24) % 256);
                bytes[i++] = (byte)((SimPort >> 8) % 256);
                bytes[i++] = (byte)(SimPort % 256);
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                if(SeedCapability == null) { Console.WriteLine("Warning: SeedCapability is null, in " + this.GetType()); }
                bytes[i++] = (byte)(SeedCapability.Length % 256);
                bytes[i++] = (byte)((SeedCapability.Length >> 8) % 256);
                Buffer.BlockCopy(SeedCapability, 0, bytes, i, SeedCapability.Length); i += SeedCapability.Length;
                bytes[i++] = SimAccess;
                bytes[i++] = (byte)(TeleportFlags % 256);
                bytes[i++] = (byte)((TeleportFlags >> 8) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 16) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("LocationID: {0}", LocationID));
                output.AppendLine(String.Format("SimIP: {0}", SimIP));
                output.AppendLine(String.Format("SimPort: {0}", SimPort));
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                Helpers.FieldToString(output, SeedCapability, "SeedCapability");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SimAccess: {0}", SimAccess));
                output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportFinish; } }
        public InfoBlock Info;

        public TeleportFinishPacket()
        {
            Header = new LowHeader();
            Header.ID = 69;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportFinishPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportFinishPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportFinish ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class StartLurePacket : Packet
    {
        /// <exclude/>
        [XmlType("startlure_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("startlure_info")]
        public class InfoBlock
        {
            public byte LureType;
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 1;
                    if (Message != null) { length += 1 + Message.Length; }
                    return length;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    LureType = (byte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = LureType;
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)Message.Length;
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("LureType: {0}", LureType));
                Helpers.FieldToString(output, Message, "Message");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("startlure_targetdata")]
        public class TargetDataBlock
        {
            public LLUUID TargetID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TargetDataBlock() { }
            public TargetDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TargetData --");
                output.Append(String.Format("TargetID: {0}", TargetID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.StartLure; } }
        public AgentDataBlock AgentData;
        public InfoBlock Info;
        public TargetDataBlock[] TargetData;

        public StartLurePacket()
        {
            Header = new LowHeader();
            Header.ID = 70;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Info = new InfoBlock();
            TargetData = new TargetDataBlock[0];
        }

        public StartLurePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
            int count = (int)bytes[i++];
            TargetData = new TargetDataBlock[count];
            for (int j = 0; j < count; j++)
            { TargetData[j] = new TargetDataBlock(bytes, ref i); }
        }

        public StartLurePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
            int count = (int)bytes[i++];
            TargetData = new TargetDataBlock[count];
            for (int j = 0; j < count; j++)
            { TargetData[j] = new TargetDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Info.Length;;
            length++;
            for (int j = 0; j < TargetData.Length; j++) { length += TargetData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            bytes[i++] = (byte)TargetData.Length;
            for (int j = 0; j < TargetData.Length; j++) { TargetData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- StartLure ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            for (int j = 0; j < TargetData.Length; j++)
            {
                output += TargetData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class TeleportLureRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportlurerequest_info")]
        public class InfoBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID LureID;
            public uint TeleportFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 52;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    LureID = new LLUUID(bytes, i); i += 16;
                    TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(LureID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(TeleportFlags % 256);
                bytes[i++] = (byte)((TeleportFlags >> 8) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 16) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("LureID: {0}", LureID));
                output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportLureRequest; } }
        public InfoBlock Info;

        public TeleportLureRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 71;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportLureRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportLureRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportLureRequest ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportCancelPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportcancel_info")]
        public class InfoBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportCancel; } }
        public InfoBlock Info;

        public TeleportCancelPacket()
        {
            Header = new LowHeader();
            Header.ID = 72;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportCancelPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportCancelPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportCancel ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportStartPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportstart_info")]
        public class InfoBlock
        {
            public uint TeleportFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(TeleportFlags % 256);
                bytes[i++] = (byte)((TeleportFlags >> 8) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 16) % 256);
                bytes[i++] = (byte)((TeleportFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportStart; } }
        public InfoBlock Info;

        public TeleportStartPacket()
        {
            Header = new LowHeader();
            Header.ID = 73;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportStartPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportStartPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportStart ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TeleportFailedPacket : Packet
    {
        /// <exclude/>
        [XmlType("teleportfailed_info")]
        public class InfoBlock
        {
            public LLUUID AgentID;
            private byte[] _reason;
            public byte[] Reason
            {
                get { return _reason; }
                set
                {
                    if (value == null) { _reason = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _reason = new byte[value.Length]; Buffer.BlockCopy(value, 0, _reason, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Reason != null) { length += 1 + Reason.Length; }
                    return length;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _reason = new byte[length];
                    Buffer.BlockCopy(bytes, i, _reason, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Reason == null) { Console.WriteLine("Warning: Reason is null, in " + this.GetType()); }
                bytes[i++] = (byte)Reason.Length;
                Buffer.BlockCopy(Reason, 0, bytes, i, Reason.Length); i += Reason.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                Helpers.FieldToString(output, Reason, "Reason");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TeleportFailed; } }
        public InfoBlock Info;

        public TeleportFailedPacket()
        {
            Header = new LowHeader();
            Header.ID = 74;
            Header.Reliable = true;
            Info = new InfoBlock();
        }

        public TeleportFailedPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Info = new InfoBlock(bytes, ref i);
        }

        public TeleportFailedPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TeleportFailed ---" + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UndoPacket : Packet
    {
        /// <exclude/>
        [XmlType("undo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("undo_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.Undo; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public UndoPacket()
        {
            Header = new LowHeader();
            Header.ID = 75;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public UndoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public UndoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- Undo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RedoPacket : Packet
    {
        /// <exclude/>
        [XmlType("redo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("redo_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.Redo; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public RedoPacket()
        {
            Header = new LowHeader();
            Header.ID = 76;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public RedoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public RedoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- Redo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UndoLandPacket : Packet
    {
        /// <exclude/>
        [XmlType("undoland_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UndoLand; } }
        public AgentDataBlock AgentData;

        public UndoLandPacket()
        {
            Header = new LowHeader();
            Header.ID = 77;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public UndoLandPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public UndoLandPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UndoLand ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentPausePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentpause_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint SerialNum;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SerialNum % 256);
                bytes[i++] = (byte)((SerialNum >> 8) % 256);
                bytes[i++] = (byte)((SerialNum >> 16) % 256);
                bytes[i++] = (byte)((SerialNum >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("SerialNum: {0}", SerialNum));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentPause; } }
        public AgentDataBlock AgentData;

        public AgentPausePacket()
        {
            Header = new LowHeader();
            Header.ID = 78;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentPausePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentPausePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentPause ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentResumePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentresume_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint SerialNum;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SerialNum % 256);
                bytes[i++] = (byte)((SerialNum >> 8) % 256);
                bytes[i++] = (byte)((SerialNum >> 16) % 256);
                bytes[i++] = (byte)((SerialNum >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("SerialNum: {0}", SerialNum));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentResume; } }
        public AgentDataBlock AgentData;

        public AgentResumePacket()
        {
            Header = new LowHeader();
            Header.ID = 79;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentResumePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentResumePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentResume ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ChatFromViewerPacket : Packet
    {
        /// <exclude/>
        [XmlType("chatfromviewer_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("chatfromviewer_chatdata")]
        public class ChatDataBlock
        {
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }
            public byte Type;
            public int Channel;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 5;
                    if (Message != null) { length += 2 + Message.Length; }
                    return length;
                }
            }

            public ChatDataBlock() { }
            public ChatDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                    Type = (byte)bytes[i++];
                    Channel = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Message.Length % 256);
                bytes[i++] = (byte)((Message.Length >> 8) % 256);
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
                bytes[i++] = Type;
                bytes[i++] = (byte)(Channel % 256);
                bytes[i++] = (byte)((Channel >> 8) % 256);
                bytes[i++] = (byte)((Channel >> 16) % 256);
                bytes[i++] = (byte)((Channel >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ChatData --");
                Helpers.FieldToString(output, Message, "Message");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Type: {0}", Type));
                output.Append(String.Format("Channel: {0}", Channel));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChatFromViewer; } }
        public AgentDataBlock AgentData;
        public ChatDataBlock ChatData;

        public ChatFromViewerPacket()
        {
            Header = new LowHeader();
            Header.ID = 80;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ChatData = new ChatDataBlock();
        }

        public ChatFromViewerPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ChatData = new ChatDataBlock(bytes, ref i);
        }

        public ChatFromViewerPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ChatData = new ChatDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ChatData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ChatData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChatFromViewer ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ChatData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentThrottlePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentthrottle_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint CircuitCode;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CircuitCode % 256);
                bytes[i++] = (byte)((CircuitCode >> 8) % 256);
                bytes[i++] = (byte)((CircuitCode >> 16) % 256);
                bytes[i++] = (byte)((CircuitCode >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("CircuitCode: {0}", CircuitCode));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentthrottle_throttle")]
        public class ThrottleBlock
        {
            public uint GenCounter;
            private byte[] _throttles;
            public byte[] Throttles
            {
                get { return _throttles; }
                set
                {
                    if (value == null) { _throttles = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _throttles = new byte[value.Length]; Buffer.BlockCopy(value, 0, _throttles, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Throttles != null) { length += 1 + Throttles.Length; }
                    return length;
                }
            }

            public ThrottleBlock() { }
            public ThrottleBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GenCounter = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _throttles = new byte[length];
                    Buffer.BlockCopy(bytes, i, _throttles, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(GenCounter % 256);
                bytes[i++] = (byte)((GenCounter >> 8) % 256);
                bytes[i++] = (byte)((GenCounter >> 16) % 256);
                bytes[i++] = (byte)((GenCounter >> 24) % 256);
                if(Throttles == null) { Console.WriteLine("Warning: Throttles is null, in " + this.GetType()); }
                bytes[i++] = (byte)Throttles.Length;
                Buffer.BlockCopy(Throttles, 0, bytes, i, Throttles.Length); i += Throttles.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Throttle --");
                output.AppendLine(String.Format("GenCounter: {0}", GenCounter));
                Helpers.FieldToString(output, Throttles, "Throttles");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentThrottle; } }
        public AgentDataBlock AgentData;
        public ThrottleBlock Throttle;

        public AgentThrottlePacket()
        {
            Header = new LowHeader();
            Header.ID = 81;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Throttle = new ThrottleBlock();
        }

        public AgentThrottlePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Throttle = new ThrottleBlock(bytes, ref i);
        }

        public AgentThrottlePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Throttle = new ThrottleBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Throttle.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Throttle.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentThrottle ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Throttle.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentFOVPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentfov_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint CircuitCode;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CircuitCode % 256);
                bytes[i++] = (byte)((CircuitCode >> 8) % 256);
                bytes[i++] = (byte)((CircuitCode >> 16) % 256);
                bytes[i++] = (byte)((CircuitCode >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("CircuitCode: {0}", CircuitCode));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentfov_fovblock")]
        public class FOVBlockBlock
        {
            public uint GenCounter;
            public float VerticalAngle;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public FOVBlockBlock() { }
            public FOVBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GenCounter = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    VerticalAngle = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(GenCounter % 256);
                bytes[i++] = (byte)((GenCounter >> 8) % 256);
                bytes[i++] = (byte)((GenCounter >> 16) % 256);
                bytes[i++] = (byte)((GenCounter >> 24) % 256);
                ba = BitConverter.GetBytes(VerticalAngle);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FOVBlock --");
                output.AppendLine(String.Format("GenCounter: {0}", GenCounter));
                output.Append(String.Format("VerticalAngle: {0}", VerticalAngle));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentFOV; } }
        public AgentDataBlock AgentData;
        public FOVBlockBlock FOVBlock;

        public AgentFOVPacket()
        {
            Header = new LowHeader();
            Header.ID = 82;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FOVBlock = new FOVBlockBlock();
        }

        public AgentFOVPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            FOVBlock = new FOVBlockBlock(bytes, ref i);
        }

        public AgentFOVPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            FOVBlock = new FOVBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += FOVBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            FOVBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentFOV ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += FOVBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentHeightWidthPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentheightwidth_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint CircuitCode;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CircuitCode % 256);
                bytes[i++] = (byte)((CircuitCode >> 8) % 256);
                bytes[i++] = (byte)((CircuitCode >> 16) % 256);
                bytes[i++] = (byte)((CircuitCode >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("CircuitCode: {0}", CircuitCode));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentheightwidth_heightwidthblock")]
        public class HeightWidthBlockBlock
        {
            public uint GenCounter;
            public ushort Height;
            public ushort Width;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public HeightWidthBlockBlock() { }
            public HeightWidthBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GenCounter = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Height = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    Width = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(GenCounter % 256);
                bytes[i++] = (byte)((GenCounter >> 8) % 256);
                bytes[i++] = (byte)((GenCounter >> 16) % 256);
                bytes[i++] = (byte)((GenCounter >> 24) % 256);
                bytes[i++] = (byte)(Height % 256);
                bytes[i++] = (byte)((Height >> 8) % 256);
                bytes[i++] = (byte)(Width % 256);
                bytes[i++] = (byte)((Width >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HeightWidthBlock --");
                output.AppendLine(String.Format("GenCounter: {0}", GenCounter));
                output.AppendLine(String.Format("Height: {0}", Height));
                output.Append(String.Format("Width: {0}", Width));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentHeightWidth; } }
        public AgentDataBlock AgentData;
        public HeightWidthBlockBlock HeightWidthBlock;

        public AgentHeightWidthPacket()
        {
            Header = new LowHeader();
            Header.ID = 83;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            HeightWidthBlock = new HeightWidthBlockBlock();
        }

        public AgentHeightWidthPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            HeightWidthBlock = new HeightWidthBlockBlock(bytes, ref i);
        }

        public AgentHeightWidthPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            HeightWidthBlock = new HeightWidthBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += HeightWidthBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            HeightWidthBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentHeightWidth ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += HeightWidthBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentSetAppearancePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentsetappearance_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint SerialNum;
            public LLVector3 Size;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Size = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SerialNum % 256);
                bytes[i++] = (byte)((SerialNum >> 8) % 256);
                bytes[i++] = (byte)((SerialNum >> 16) % 256);
                bytes[i++] = (byte)((SerialNum >> 24) % 256);
                Buffer.BlockCopy(Size.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("SerialNum: {0}", SerialNum));
                output.Append(String.Format("Size: {0}", Size));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentsetappearance_wearabledata")]
        public class WearableDataBlock
        {
            public LLUUID CacheID;
            public byte TextureIndex;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public WearableDataBlock() { }
            public WearableDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    CacheID = new LLUUID(bytes, i); i += 16;
                    TextureIndex = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(CacheID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = TextureIndex;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- WearableData --");
                output.AppendLine(String.Format("CacheID: {0}", CacheID));
                output.Append(String.Format("TextureIndex: {0}", TextureIndex));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentsetappearance_objectdata")]
        public class ObjectDataBlock
        {
            private byte[] _textureentry;
            public byte[] TextureEntry
            {
                get { return _textureentry; }
                set
                {
                    if (value == null) { _textureentry = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _textureentry = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
                bytes[i++] = (byte)(TextureEntry.Length % 256);
                bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
                Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                Helpers.FieldToString(output, TextureEntry, "TextureEntry");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentsetappearance_visualparam")]
        public class VisualParamBlock
        {
            public byte ParamValue;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public VisualParamBlock() { }
            public VisualParamBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ParamValue = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = ParamValue;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- VisualParam --");
                output.Append(String.Format("ParamValue: {0}", ParamValue));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentSetAppearance; } }
        public AgentDataBlock AgentData;
        public WearableDataBlock[] WearableData;
        public ObjectDataBlock ObjectData;
        public VisualParamBlock[] VisualParam;

        public AgentSetAppearancePacket()
        {
            Header = new LowHeader();
            Header.ID = 84;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            WearableData = new WearableDataBlock[0];
            ObjectData = new ObjectDataBlock();
            VisualParam = new VisualParamBlock[0];
        }

        public AgentSetAppearancePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
            ObjectData = new ObjectDataBlock(bytes, ref i);
            count = (int)bytes[i++];
            VisualParam = new VisualParamBlock[count];
            for (int j = 0; j < count; j++)
            { VisualParam[j] = new VisualParamBlock(bytes, ref i); }
        }

        public AgentSetAppearancePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
            ObjectData = new ObjectDataBlock(bytes, ref i);
            count = (int)bytes[i++];
            VisualParam = new VisualParamBlock[count];
            for (int j = 0; j < count; j++)
            { VisualParam[j] = new VisualParamBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            length++;
            for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
            length++;
            for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)WearableData.Length;
            for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
            ObjectData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)VisualParam.Length;
            for (int j = 0; j < VisualParam.Length; j++) { VisualParam[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentSetAppearance ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < WearableData.Length; j++)
            {
                output += WearableData[j].ToString() + Environment.NewLine;
            }
                output += ObjectData.ToString() + Environment.NewLine;
            for (int j = 0; j < VisualParam.Length; j++)
            {
                output += VisualParam[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentQuitCopyPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentquitcopy_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentquitcopy_fuseblock")]
        public class FuseBlockBlock
        {
            public uint ViewerCircuitCode;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public FuseBlockBlock() { }
            public FuseBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ViewerCircuitCode % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 8) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 16) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FuseBlock --");
                output.Append(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentQuitCopy; } }
        public AgentDataBlock AgentData;
        public FuseBlockBlock FuseBlock;

        public AgentQuitCopyPacket()
        {
            Header = new LowHeader();
            Header.ID = 85;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FuseBlock = new FuseBlockBlock();
        }

        public AgentQuitCopyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            FuseBlock = new FuseBlockBlock(bytes, ref i);
        }

        public AgentQuitCopyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            FuseBlock = new FuseBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += FuseBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            FuseBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentQuitCopy ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += FuseBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ImageNotInDatabasePacket : Packet
    {
        /// <exclude/>
        [XmlType("imagenotindatabase_imageid")]
        public class ImageIDBlock
        {
            public LLUUID ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ImageIDBlock() { }
            public ImageIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ImageID --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ImageNotInDatabase; } }
        public ImageIDBlock ImageID;

        public ImageNotInDatabasePacket()
        {
            Header = new LowHeader();
            Header.ID = 86;
            Header.Reliable = true;
            ImageID = new ImageIDBlock();
        }

        public ImageNotInDatabasePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ImageID = new ImageIDBlock(bytes, ref i);
        }

        public ImageNotInDatabasePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ImageID = new ImageIDBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ImageID.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ImageID.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ImageNotInDatabase ---" + Environment.NewLine;
                output += ImageID.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RebakeAvatarTexturesPacket : Packet
    {
        /// <exclude/>
        [XmlType("rebakeavatartextures_texturedata")]
        public class TextureDataBlock
        {
            public LLUUID TextureID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TextureDataBlock() { }
            public TextureDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TextureID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TextureID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TextureData --");
                output.Append(String.Format("TextureID: {0}", TextureID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RebakeAvatarTextures; } }
        public TextureDataBlock TextureData;

        public RebakeAvatarTexturesPacket()
        {
            Header = new LowHeader();
            Header.ID = 87;
            Header.Reliable = true;
            TextureData = new TextureDataBlock();
        }

        public RebakeAvatarTexturesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TextureData = new TextureDataBlock(bytes, ref i);
        }

        public RebakeAvatarTexturesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TextureData = new TextureDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TextureData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TextureData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RebakeAvatarTextures ---" + Environment.NewLine;
                output += TextureData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SetAlwaysRunPacket : Packet
    {
        /// <exclude/>
        [XmlType("setalwaysrun_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public bool AlwaysRun;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    AlwaysRun = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((AlwaysRun) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("AlwaysRun: {0}", AlwaysRun));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SetAlwaysRun; } }
        public AgentDataBlock AgentData;

        public SetAlwaysRunPacket()
        {
            Header = new LowHeader();
            Header.ID = 88;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public SetAlwaysRunPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public SetAlwaysRunPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SetAlwaysRun ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDeletePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdelete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public bool Force;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Force = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Force) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("Force: {0}", Force));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdelete_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDelete; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDeletePacket()
        {
            Header = new LowHeader();
            Header.ID = 89;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDeletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDeletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDelete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDuplicatePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectduplicate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectduplicate_shareddata")]
        public class SharedDataBlock
        {
            public LLVector3 Offset;
            public uint DuplicateFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public SharedDataBlock() { }
            public SharedDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Offset = new LLVector3(bytes, i); i += 12;
                    DuplicateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(Offset.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)(DuplicateFlags % 256);
                bytes[i++] = (byte)((DuplicateFlags >> 8) % 256);
                bytes[i++] = (byte)((DuplicateFlags >> 16) % 256);
                bytes[i++] = (byte)((DuplicateFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SharedData --");
                output.AppendLine(String.Format("Offset: {0}", Offset));
                output.Append(String.Format("DuplicateFlags: {0}", DuplicateFlags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectduplicate_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDuplicate; } }
        public AgentDataBlock AgentData;
        public SharedDataBlock SharedData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDuplicatePacket()
        {
            Header = new LowHeader();
            Header.ID = 90;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            SharedData = new SharedDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDuplicatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            SharedData = new SharedDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDuplicatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            SharedData = new SharedDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += SharedData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            SharedData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDuplicate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += SharedData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDuplicateOnRayPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectduplicateonray_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;
            public LLVector3 RayStart;
            public LLVector3 RayEnd;
            public bool BypassRaycast;
            public bool RayEndIsIntersection;
            public bool CopyCenters;
            public bool CopyRotates;
            public LLUUID RayTargetID;
            public uint DuplicateFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 96;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RayStart = new LLVector3(bytes, i); i += 12;
                    RayEnd = new LLVector3(bytes, i); i += 12;
                    BypassRaycast = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RayEndIsIntersection = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    CopyCenters = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    CopyRotates = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RayTargetID = new LLUUID(bytes, i); i += 16;
                    DuplicateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)((BypassRaycast) ? 1 : 0);
                bytes[i++] = (byte)((RayEndIsIntersection) ? 1 : 0);
                bytes[i++] = (byte)((CopyCenters) ? 1 : 0);
                bytes[i++] = (byte)((CopyRotates) ? 1 : 0);
                Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(DuplicateFlags % 256);
                bytes[i++] = (byte)((DuplicateFlags >> 8) % 256);
                bytes[i++] = (byte)((DuplicateFlags >> 16) % 256);
                bytes[i++] = (byte)((DuplicateFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("RayStart: {0}", RayStart));
                output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
                output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
                output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
                output.AppendLine(String.Format("CopyCenters: {0}", CopyCenters));
                output.AppendLine(String.Format("CopyRotates: {0}", CopyRotates));
                output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
                output.Append(String.Format("DuplicateFlags: {0}", DuplicateFlags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectduplicateonray_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDuplicateOnRay; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDuplicateOnRayPacket()
        {
            Header = new LowHeader();
            Header.ID = 91;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDuplicateOnRayPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDuplicateOnRayPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDuplicateOnRay ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectScalePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectscale_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectscale_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public LLVector3 Scale;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Scale = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                Buffer.BlockCopy(Scale.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("Scale: {0}", Scale));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectScale; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectScalePacket()
        {
            Header = new LowHeader();
            Header.ID = 92;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectScalePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectScalePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectScale ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectRotationPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectrotation_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectrotation_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public LLQuaternion Rotation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Rotation = new LLQuaternion(bytes, i, true); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("Rotation: {0}", Rotation));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectRotation; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectRotationPacket()
        {
            Header = new LowHeader();
            Header.ID = 93;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectRotationPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectRotationPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectRotation ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectFlagUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectflagupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint ObjectLocalID;
            public bool UsePhysics;
            public bool IsTemporary;
            public bool IsPhantom;
            public bool CastsShadows;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 40;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    UsePhysics = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    IsTemporary = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    IsPhantom = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    CastsShadows = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = (byte)((UsePhysics) ? 1 : 0);
                bytes[i++] = (byte)((IsTemporary) ? 1 : 0);
                bytes[i++] = (byte)((IsPhantom) ? 1 : 0);
                bytes[i++] = (byte)((CastsShadows) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.AppendLine(String.Format("UsePhysics: {0}", UsePhysics));
                output.AppendLine(String.Format("IsTemporary: {0}", IsTemporary));
                output.AppendLine(String.Format("IsPhantom: {0}", IsPhantom));
                output.Append(String.Format("CastsShadows: {0}", CastsShadows));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectFlagUpdate; } }
        public AgentDataBlock AgentData;

        public ObjectFlagUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 94;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ObjectFlagUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ObjectFlagUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectFlagUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectClickActionPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectclickaction_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectclickaction_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public byte ClickAction;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 5;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ClickAction = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = ClickAction;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("ClickAction: {0}", ClickAction));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectClickAction; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectClickActionPacket()
        {
            Header = new LowHeader();
            Header.ID = 95;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectClickActionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectClickActionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectClickAction ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectImagePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectimage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectimage_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            private byte[] _mediaurl;
            public byte[] MediaURL
            {
                get { return _mediaurl; }
                set
                {
                    if (value == null) { _mediaurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
                }
            }
            private byte[] _textureentry;
            public byte[] TextureEntry
            {
                get { return _textureentry; }
                set
                {
                    if (value == null) { _textureentry = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (MediaURL != null) { length += 1 + MediaURL.Length; }
                    if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _mediaurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _textureentry = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MediaURL.Length;
                Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
                if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
                bytes[i++] = (byte)(TextureEntry.Length % 256);
                bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
                Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                Helpers.FieldToString(output, MediaURL, "MediaURL");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TextureEntry, "TextureEntry");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectImage; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectImagePacket()
        {
            Header = new LowHeader();
            Header.ID = 96;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectImagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectImagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectImage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectMaterialPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectmaterial_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectmaterial_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public byte Material;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 5;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Material = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = Material;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("Material: {0}", Material));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectMaterial; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectMaterialPacket()
        {
            Header = new LowHeader();
            Header.ID = 97;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectMaterialPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectMaterialPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectMaterial ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectShapePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectshape_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectshape_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public byte PathCurve;
            public byte ProfileCurve;
            public ushort PathBegin;
            public ushort PathEnd;
            public byte PathScaleX;
            public byte PathScaleY;
            public byte PathShearX;
            public byte PathShearY;
            public sbyte PathTwist;
            public sbyte PathTwistBegin;
            public sbyte PathRadiusOffset;
            public sbyte PathTaperX;
            public sbyte PathTaperY;
            public byte PathRevolutions;
            public sbyte PathSkew;
            public ushort ProfileBegin;
            public ushort ProfileEnd;
            public ushort ProfileHollow;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 27;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PathCurve = (byte)bytes[i++];
                    ProfileCurve = (byte)bytes[i++];
                    PathBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    PathEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    PathScaleX = (byte)bytes[i++];
                    PathScaleY = (byte)bytes[i++];
                    PathShearX = (byte)bytes[i++];
                    PathShearY = (byte)bytes[i++];
                    PathTwist = (sbyte)bytes[i++];
                    PathTwistBegin = (sbyte)bytes[i++];
                    PathRadiusOffset = (sbyte)bytes[i++];
                    PathTaperX = (sbyte)bytes[i++];
                    PathTaperY = (sbyte)bytes[i++];
                    PathRevolutions = (byte)bytes[i++];
                    PathSkew = (sbyte)bytes[i++];
                    ProfileBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ProfileEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ProfileHollow = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = PathCurve;
                bytes[i++] = ProfileCurve;
                bytes[i++] = (byte)(PathBegin % 256);
                bytes[i++] = (byte)((PathBegin >> 8) % 256);
                bytes[i++] = (byte)(PathEnd % 256);
                bytes[i++] = (byte)((PathEnd >> 8) % 256);
                bytes[i++] = PathScaleX;
                bytes[i++] = PathScaleY;
                bytes[i++] = PathShearX;
                bytes[i++] = PathShearY;
                bytes[i++] = (byte)PathTwist;
                bytes[i++] = (byte)PathTwistBegin;
                bytes[i++] = (byte)PathRadiusOffset;
                bytes[i++] = (byte)PathTaperX;
                bytes[i++] = (byte)PathTaperY;
                bytes[i++] = PathRevolutions;
                bytes[i++] = (byte)PathSkew;
                bytes[i++] = (byte)(ProfileBegin % 256);
                bytes[i++] = (byte)((ProfileBegin >> 8) % 256);
                bytes[i++] = (byte)(ProfileEnd % 256);
                bytes[i++] = (byte)((ProfileEnd >> 8) % 256);
                bytes[i++] = (byte)(ProfileHollow % 256);
                bytes[i++] = (byte)((ProfileHollow >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.AppendLine(String.Format("PathCurve: {0}", PathCurve));
                output.AppendLine(String.Format("ProfileCurve: {0}", ProfileCurve));
                output.AppendLine(String.Format("PathBegin: {0}", PathBegin));
                output.AppendLine(String.Format("PathEnd: {0}", PathEnd));
                output.AppendLine(String.Format("PathScaleX: {0}", PathScaleX));
                output.AppendLine(String.Format("PathScaleY: {0}", PathScaleY));
                output.AppendLine(String.Format("PathShearX: {0}", PathShearX));
                output.AppendLine(String.Format("PathShearY: {0}", PathShearY));
                output.AppendLine(String.Format("PathTwist: {0}", PathTwist));
                output.AppendLine(String.Format("PathTwistBegin: {0}", PathTwistBegin));
                output.AppendLine(String.Format("PathRadiusOffset: {0}", PathRadiusOffset));
                output.AppendLine(String.Format("PathTaperX: {0}", PathTaperX));
                output.AppendLine(String.Format("PathTaperY: {0}", PathTaperY));
                output.AppendLine(String.Format("PathRevolutions: {0}", PathRevolutions));
                output.AppendLine(String.Format("PathSkew: {0}", PathSkew));
                output.AppendLine(String.Format("ProfileBegin: {0}", ProfileBegin));
                output.AppendLine(String.Format("ProfileEnd: {0}", ProfileEnd));
                output.Append(String.Format("ProfileHollow: {0}", ProfileHollow));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectShape; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectShapePacket()
        {
            Header = new LowHeader();
            Header.ID = 98;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectShapePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectShapePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectShape ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectExtraParamsPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectextraparams_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectextraparams_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public ushort ParamType;
            public bool ParamInUse;
            public uint ParamSize;
            private byte[] _paramdata;
            public byte[] ParamData
            {
                get { return _paramdata; }
                set
                {
                    if (value == null) { _paramdata = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _paramdata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _paramdata, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 11;
                    if (ParamData != null) { length += 1 + ParamData.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParamType = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ParamInUse = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ParamSize = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _paramdata = new byte[length];
                    Buffer.BlockCopy(bytes, i, _paramdata, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = (byte)(ParamType % 256);
                bytes[i++] = (byte)((ParamType >> 8) % 256);
                bytes[i++] = (byte)((ParamInUse) ? 1 : 0);
                bytes[i++] = (byte)(ParamSize % 256);
                bytes[i++] = (byte)((ParamSize >> 8) % 256);
                bytes[i++] = (byte)((ParamSize >> 16) % 256);
                bytes[i++] = (byte)((ParamSize >> 24) % 256);
                if(ParamData == null) { Console.WriteLine("Warning: ParamData is null, in " + this.GetType()); }
                bytes[i++] = (byte)ParamData.Length;
                Buffer.BlockCopy(ParamData, 0, bytes, i, ParamData.Length); i += ParamData.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.AppendLine(String.Format("ParamType: {0}", ParamType));
                output.AppendLine(String.Format("ParamInUse: {0}", ParamInUse));
                output.AppendLine(String.Format("ParamSize: {0}", ParamSize));
                Helpers.FieldToString(output, ParamData, "ParamData");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectExtraParams; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectExtraParamsPacket()
        {
            Header = new LowHeader();
            Header.ID = 99;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectExtraParamsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectExtraParamsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectExtraParams ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectOwnerPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectowner_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectowner_headerdata")]
        public class HeaderDataBlock
        {
            public bool Override;
            public LLUUID OwnerID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public HeaderDataBlock() { }
            public HeaderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Override = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((Override) ? 1 : 0);
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HeaderData --");
                output.AppendLine(String.Format("Override: {0}", Override));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectowner_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectOwner; } }
        public AgentDataBlock AgentData;
        public HeaderDataBlock HeaderData;
        public ObjectDataBlock[] ObjectData;

        public ObjectOwnerPacket()
        {
            Header = new LowHeader();
            Header.ID = 100;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            HeaderData = new HeaderDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectOwnerPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectOwnerPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += HeaderData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            HeaderData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectOwner ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += HeaderData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectGroupPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectgroup_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectgroup_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectGroup; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectGroupPacket()
        {
            Header = new LowHeader();
            Header.ID = 101;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectGroupPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectGroupPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectGroup ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectBuyPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectbuy_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;
            public LLUUID CategoryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 64;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    CategoryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CategoryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("CategoryID: {0}", CategoryID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectbuy_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public byte SaleType;
            public int SalePrice;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 9;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.Append(String.Format("SalePrice: {0}", SalePrice));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectBuy; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectBuyPacket()
        {
            Header = new LowHeader();
            Header.ID = 102;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectBuyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectBuyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectBuy ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class BuyObjectInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("buyobjectinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("buyobjectinventory_data")]
        public class DataBlock
        {
            public LLUUID ObjectID;
            public LLUUID ItemID;
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.BuyObjectInventory; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public BuyObjectInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 103;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public BuyObjectInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public BuyObjectInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- BuyObjectInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DerezContainerPacket : Packet
    {
        /// <exclude/>
        [XmlType("derezcontainer_data")]
        public class DataBlock
        {
            public LLUUID ObjectID;
            public bool Delete;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    Delete = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Delete) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("Delete: {0}", Delete));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DerezContainer; } }
        public DataBlock Data;

        public DerezContainerPacket()
        {
            Header = new LowHeader();
            Header.ID = 104;
            Header.Reliable = true;
            Data = new DataBlock();
        }

        public DerezContainerPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
        }

        public DerezContainerPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DerezContainer ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectPermissionsPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectpermissions_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectpermissions_headerdata")]
        public class HeaderDataBlock
        {
            public bool Override;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public HeaderDataBlock() { }
            public HeaderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Override = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((Override) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HeaderData --");
                output.Append(String.Format("Override: {0}", Override));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectpermissions_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public byte Field;
            public byte Set;
            public uint Mask;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 10;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Field = (byte)bytes[i++];
                    Set = (byte)bytes[i++];
                    Mask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = Field;
                bytes[i++] = Set;
                bytes[i++] = (byte)(Mask % 256);
                bytes[i++] = (byte)((Mask >> 8) % 256);
                bytes[i++] = (byte)((Mask >> 16) % 256);
                bytes[i++] = (byte)((Mask >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.AppendLine(String.Format("Field: {0}", Field));
                output.AppendLine(String.Format("Set: {0}", Set));
                output.Append(String.Format("Mask: {0}", Mask));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectPermissions; } }
        public AgentDataBlock AgentData;
        public HeaderDataBlock HeaderData;
        public ObjectDataBlock[] ObjectData;

        public ObjectPermissionsPacket()
        {
            Header = new LowHeader();
            Header.ID = 105;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            HeaderData = new HeaderDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectPermissionsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectPermissionsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += HeaderData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            HeaderData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectPermissions ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += HeaderData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectSaleInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectsaleinfo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectsaleinfo_objectdata")]
        public class ObjectDataBlock
        {
            public uint LocalID;
            public byte SaleType;
            public int SalePrice;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 9;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.Append(String.Format("SalePrice: {0}", SalePrice));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectSaleInfo; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectSaleInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 106;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectSaleInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectSaleInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectSaleInfo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectNamePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectname_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectname_objectdata")]
        public class ObjectDataBlock
        {
            public uint LocalID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectName; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectNamePacket()
        {
            Header = new LowHeader();
            Header.ID = 107;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectNamePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectNamePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectName ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDescriptionPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdescription_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdescription_objectdata")]
        public class ObjectDataBlock
        {
            public uint LocalID;
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDescription; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDescriptionPacket()
        {
            Header = new LowHeader();
            Header.ID = 108;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDescriptionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDescriptionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDescription ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectCategoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectcategory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectcategory_objectdata")]
        public class ObjectDataBlock
        {
            public uint LocalID;
            public uint Category;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)(Category % 256);
                bytes[i++] = (byte)((Category >> 8) % 256);
                bytes[i++] = (byte)((Category >> 16) % 256);
                bytes[i++] = (byte)((Category >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("Category: {0}", Category));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectCategory; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectCategoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 109;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectCategoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectCategoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectCategory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectSelectPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectselect_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectselect_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectSelect; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectSelectPacket()
        {
            Header = new LowHeader();
            Header.ID = 110;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectSelectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectSelectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectSelect ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDeselectPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdeselect_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdeselect_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDeselect; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDeselectPacket()
        {
            Header = new LowHeader();
            Header.ID = 111;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDeselectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDeselectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDeselect ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectAttachPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectattach_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public byte AttachmentPoint;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    AttachmentPoint = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = AttachmentPoint;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("AttachmentPoint: {0}", AttachmentPoint));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectattach_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public LLQuaternion Rotation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Rotation = new LLQuaternion(bytes, i, true); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("Rotation: {0}", Rotation));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectAttach; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectAttachPacket()
        {
            Header = new LowHeader();
            Header.ID = 112;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectAttachPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectAttachPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectAttach ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDetachPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdetach_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdetach_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDetach; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDetachPacket()
        {
            Header = new LowHeader();
            Header.ID = 113;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDetachPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDetachPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDetach ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDropPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdrop_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdrop_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDrop; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDropPacket()
        {
            Header = new LowHeader();
            Header.ID = 114;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDropPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDropPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDrop ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectLinkPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectlink_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectlink_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectLink; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectLinkPacket()
        {
            Header = new LowHeader();
            Header.ID = 115;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectLinkPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectLinkPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectLink ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDelinkPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdelink_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdelink_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDelink; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectDelinkPacket()
        {
            Header = new LowHeader();
            Header.ID = 116;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectDelinkPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectDelinkPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDelink ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectGrabPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectgrab_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectgrab_objectdata")]
        public class ObjectDataBlock
        {
            public uint LocalID;
            public LLVector3 GrabOffset;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GrabOffset = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(GrabOffset.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("GrabOffset: {0}", GrabOffset));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectGrab; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectGrabPacket()
        {
            Header = new LowHeader();
            Header.ID = 117;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectGrabPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectGrabPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectGrab ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectGrabUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectgrabupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectgrabupdate_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;
            public LLVector3 GrabOffsetInitial;
            public LLVector3 GrabPosition;
            public uint TimeSinceLast;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 44;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    GrabOffsetInitial = new LLVector3(bytes, i); i += 12;
                    GrabPosition = new LLVector3(bytes, i); i += 12;
                    TimeSinceLast = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GrabOffsetInitial.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(GrabPosition.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)(TimeSinceLast % 256);
                bytes[i++] = (byte)((TimeSinceLast >> 8) % 256);
                bytes[i++] = (byte)((TimeSinceLast >> 16) % 256);
                bytes[i++] = (byte)((TimeSinceLast >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("GrabOffsetInitial: {0}", GrabOffsetInitial));
                output.AppendLine(String.Format("GrabPosition: {0}", GrabPosition));
                output.Append(String.Format("TimeSinceLast: {0}", TimeSinceLast));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectGrabUpdate; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectGrabUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 118;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectGrabUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectGrabUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectGrabUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectDeGrabPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectdegrab_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectdegrab_objectdata")]
        public class ObjectDataBlock
        {
            public uint LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectDeGrab; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectDeGrabPacket()
        {
            Header = new LowHeader();
            Header.ID = 119;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectDeGrabPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectDeGrabPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectDeGrab ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectSpinStartPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectspinstart_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectspinstart_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectSpinStart; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectSpinStartPacket()
        {
            Header = new LowHeader();
            Header.ID = 120;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectSpinStartPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectSpinStartPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectSpinStart ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectSpinUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectspinupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectspinupdate_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;
            public LLQuaternion Rotation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 28;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    Rotation = new LLQuaternion(bytes, i, true); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("Rotation: {0}", Rotation));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectSpinUpdate; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectSpinUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 121;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectSpinUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectSpinUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectSpinUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectSpinStopPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectspinstop_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectspinstop_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectSpinStop; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectSpinStopPacket()
        {
            Header = new LowHeader();
            Header.ID = 122;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectSpinStopPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectSpinStopPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectSpinStop ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectExportSelectedPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectexportselected_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID RequestID;
            public short VolumeDetail;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 34;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                    VolumeDetail = (short)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(VolumeDetail % 256);
                bytes[i++] = (byte)((VolumeDetail >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.Append(String.Format("VolumeDetail: {0}", VolumeDetail));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectexportselected_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectExportSelected; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectExportSelectedPacket()
        {
            Header = new LowHeader();
            Header.ID = 123;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectExportSelectedPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectExportSelectedPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectExportSelected ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ModifyLandPacket : Packet
    {
        /// <exclude/>
        [XmlType("modifyland_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("modifyland_modifyblock")]
        public class ModifyBlockBlock
        {
            public byte Action;
            public byte BrushSize;
            public float Seconds;
            public float Height;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 10;
                }
            }

            public ModifyBlockBlock() { }
            public ModifyBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Action = (byte)bytes[i++];
                    BrushSize = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Seconds = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Height = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = Action;
                bytes[i++] = BrushSize;
                ba = BitConverter.GetBytes(Seconds);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(Height);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ModifyBlock --");
                output.AppendLine(String.Format("Action: {0}", Action));
                output.AppendLine(String.Format("BrushSize: {0}", BrushSize));
                output.AppendLine(String.Format("Seconds: {0}", Seconds));
                output.Append(String.Format("Height: {0}", Height));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("modifyland_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public float West;
            public float South;
            public float East;
            public float North;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    West = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    South = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    East = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    North = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                ba = BitConverter.GetBytes(West);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(South);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(East);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(North);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.AppendLine(String.Format("West: {0}", West));
                output.AppendLine(String.Format("South: {0}", South));
                output.AppendLine(String.Format("East: {0}", East));
                output.Append(String.Format("North: {0}", North));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ModifyLand; } }
        public AgentDataBlock AgentData;
        public ModifyBlockBlock ModifyBlock;
        public ParcelDataBlock[] ParcelData;

        public ModifyLandPacket()
        {
            Header = new LowHeader();
            Header.ID = 124;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ModifyBlock = new ModifyBlockBlock();
            ParcelData = new ParcelDataBlock[0];
        }

        public ModifyLandPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ModifyBlock = new ModifyBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParcelData = new ParcelDataBlock[count];
            for (int j = 0; j < count; j++)
            { ParcelData[j] = new ParcelDataBlock(bytes, ref i); }
        }

        public ModifyLandPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ModifyBlock = new ModifyBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParcelData = new ParcelDataBlock[count];
            for (int j = 0; j < count; j++)
            { ParcelData[j] = new ParcelDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ModifyBlock.Length;;
            length++;
            for (int j = 0; j < ParcelData.Length; j++) { length += ParcelData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ModifyBlock.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ParcelData.Length;
            for (int j = 0; j < ParcelData.Length; j++) { ParcelData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ModifyLand ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ModifyBlock.ToString() + Environment.NewLine;
            for (int j = 0; j < ParcelData.Length; j++)
            {
                output += ParcelData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class VelocityInterpolateOnPacket : Packet
    {
        /// <exclude/>
        [XmlType("velocityinterpolateon_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.VelocityInterpolateOn; } }
        public AgentDataBlock AgentData;

        public VelocityInterpolateOnPacket()
        {
            Header = new LowHeader();
            Header.ID = 125;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public VelocityInterpolateOnPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public VelocityInterpolateOnPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- VelocityInterpolateOn ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class VelocityInterpolateOffPacket : Packet
    {
        /// <exclude/>
        [XmlType("velocityinterpolateoff_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.VelocityInterpolateOff; } }
        public AgentDataBlock AgentData;

        public VelocityInterpolateOffPacket()
        {
            Header = new LowHeader();
            Header.ID = 126;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public VelocityInterpolateOffPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public VelocityInterpolateOffPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- VelocityInterpolateOff ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class StateSavePacket : Packet
    {
        /// <exclude/>
        [XmlType("statesave_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("statesave_datablock")]
        public class DataBlockBlock
        {
            private byte[] _filename;
            public byte[] Filename
            {
                get { return _filename; }
                set
                {
                    if (value == null) { _filename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Filename != null) { length += 1 + Filename.Length; }
                    return length;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _filename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
                bytes[i++] = (byte)Filename.Length;
                Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                Helpers.FieldToString(output, Filename, "Filename");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.StateSave; } }
        public AgentDataBlock AgentData;
        public DataBlockBlock DataBlock;

        public StateSavePacket()
        {
            Header = new LowHeader();
            Header.ID = 127;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            DataBlock = new DataBlockBlock();
        }

        public StateSavePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public StateSavePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- StateSave ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ReportAutosaveCrashPacket : Packet
    {
        /// <exclude/>
        [XmlType("reportautosavecrash_autosavedata")]
        public class AutosaveDataBlock
        {
            public int PID;
            public int Status;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public AutosaveDataBlock() { }
            public AutosaveDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Status = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(PID % 256);
                bytes[i++] = (byte)((PID >> 8) % 256);
                bytes[i++] = (byte)((PID >> 16) % 256);
                bytes[i++] = (byte)((PID >> 24) % 256);
                bytes[i++] = (byte)(Status % 256);
                bytes[i++] = (byte)((Status >> 8) % 256);
                bytes[i++] = (byte)((Status >> 16) % 256);
                bytes[i++] = (byte)((Status >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AutosaveData --");
                output.AppendLine(String.Format("PID: {0}", PID));
                output.Append(String.Format("Status: {0}", Status));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ReportAutosaveCrash; } }
        public AutosaveDataBlock AutosaveData;

        public ReportAutosaveCrashPacket()
        {
            Header = new LowHeader();
            Header.ID = 128;
            Header.Reliable = true;
            AutosaveData = new AutosaveDataBlock();
        }

        public ReportAutosaveCrashPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AutosaveData = new AutosaveDataBlock(bytes, ref i);
        }

        public ReportAutosaveCrashPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AutosaveData = new AutosaveDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AutosaveData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AutosaveData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ReportAutosaveCrash ---" + Environment.NewLine;
                output += AutosaveData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SimWideDeletesPacket : Packet
    {
        /// <exclude/>
        [XmlType("simwidedeletes_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("simwidedeletes_datablock")]
        public class DataBlockBlock
        {
            public LLUUID TargetID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                output.AppendLine(String.Format("TargetID: {0}", TargetID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SimWideDeletes; } }
        public AgentDataBlock AgentData;
        public DataBlockBlock DataBlock;

        public SimWideDeletesPacket()
        {
            Header = new LowHeader();
            Header.ID = 129;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            DataBlock = new DataBlockBlock();
        }

        public SimWideDeletesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public SimWideDeletesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SimWideDeletes ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TrackAgentPacket : Packet
    {
        /// <exclude/>
        [XmlType("trackagent_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("trackagent_targetdata")]
        public class TargetDataBlock
        {
            public LLUUID PreyID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TargetDataBlock() { }
            public TargetDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PreyID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(PreyID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TargetData --");
                output.Append(String.Format("PreyID: {0}", PreyID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TrackAgent; } }
        public AgentDataBlock AgentData;
        public TargetDataBlock TargetData;

        public TrackAgentPacket()
        {
            Header = new LowHeader();
            Header.ID = 130;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TargetData = new TargetDataBlock();
        }

        public TrackAgentPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TargetData = new TargetDataBlock(bytes, ref i);
        }

        public TrackAgentPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TargetData = new TargetDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TargetData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TargetData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TrackAgent ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TargetData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ViewerStatsPacket : Packet
    {
        /// <exclude/>
        [XmlType("viewerstats_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint IP;
            public uint StartTime;
            public float RunTime;
            public float SimFPS;
            public float FPS;
            public byte AgentsInView;
            public float Ping;
            public double MetersTraveled;
            public int RegionsVisited;
            public uint SysRAM;
            private byte[] _sysos;
            public byte[] SysOS
            {
                get { return _sysos; }
                set
                {
                    if (value == null) { _sysos = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _sysos = new byte[value.Length]; Buffer.BlockCopy(value, 0, _sysos, 0, value.Length); }
                }
            }
            private byte[] _syscpu;
            public byte[] SysCPU
            {
                get { return _syscpu; }
                set
                {
                    if (value == null) { _syscpu = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _syscpu = new byte[value.Length]; Buffer.BlockCopy(value, 0, _syscpu, 0, value.Length); }
                }
            }
            private byte[] _sysgpu;
            public byte[] SysGPU
            {
                get { return _sysgpu; }
                set
                {
                    if (value == null) { _sysgpu = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _sysgpu = new byte[value.Length]; Buffer.BlockCopy(value, 0, _sysgpu, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 73;
                    if (SysOS != null) { length += 1 + SysOS.Length; }
                    if (SysCPU != null) { length += 1 + SysCPU.Length; }
                    if (SysGPU != null) { length += 1 + SysGPU.Length; }
                    return length;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    IP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    StartTime = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    RunTime = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    SimFPS = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    FPS = BitConverter.ToSingle(bytes, i); i += 4;
                    AgentsInView = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Ping = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 8);
                    MetersTraveled = BitConverter.ToDouble(bytes, i); i += 8;
                    RegionsVisited = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SysRAM = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _sysos = new byte[length];
                    Buffer.BlockCopy(bytes, i, _sysos, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _syscpu = new byte[length];
                    Buffer.BlockCopy(bytes, i, _syscpu, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _sysgpu = new byte[length];
                    Buffer.BlockCopy(bytes, i, _sysgpu, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IP % 256);
                bytes[i++] = (byte)((IP >> 8) % 256);
                bytes[i++] = (byte)((IP >> 16) % 256);
                bytes[i++] = (byte)((IP >> 24) % 256);
                bytes[i++] = (byte)(StartTime % 256);
                bytes[i++] = (byte)((StartTime >> 8) % 256);
                bytes[i++] = (byte)((StartTime >> 16) % 256);
                bytes[i++] = (byte)((StartTime >> 24) % 256);
                ba = BitConverter.GetBytes(RunTime);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(SimFPS);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(FPS);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = AgentsInView;
                ba = BitConverter.GetBytes(Ping);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(MetersTraveled);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 8); }
                Buffer.BlockCopy(ba, 0, bytes, i, 8); i += 8;
                bytes[i++] = (byte)(RegionsVisited % 256);
                bytes[i++] = (byte)((RegionsVisited >> 8) % 256);
                bytes[i++] = (byte)((RegionsVisited >> 16) % 256);
                bytes[i++] = (byte)((RegionsVisited >> 24) % 256);
                bytes[i++] = (byte)(SysRAM % 256);
                bytes[i++] = (byte)((SysRAM >> 8) % 256);
                bytes[i++] = (byte)((SysRAM >> 16) % 256);
                bytes[i++] = (byte)((SysRAM >> 24) % 256);
                if(SysOS == null) { Console.WriteLine("Warning: SysOS is null, in " + this.GetType()); }
                bytes[i++] = (byte)SysOS.Length;
                Buffer.BlockCopy(SysOS, 0, bytes, i, SysOS.Length); i += SysOS.Length;
                if(SysCPU == null) { Console.WriteLine("Warning: SysCPU is null, in " + this.GetType()); }
                bytes[i++] = (byte)SysCPU.Length;
                Buffer.BlockCopy(SysCPU, 0, bytes, i, SysCPU.Length); i += SysCPU.Length;
                if(SysGPU == null) { Console.WriteLine("Warning: SysGPU is null, in " + this.GetType()); }
                bytes[i++] = (byte)SysGPU.Length;
                Buffer.BlockCopy(SysGPU, 0, bytes, i, SysGPU.Length); i += SysGPU.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("IP: {0}", IP));
                output.AppendLine(String.Format("StartTime: {0}", StartTime));
                output.AppendLine(String.Format("RunTime: {0}", RunTime));
                output.AppendLine(String.Format("SimFPS: {0}", SimFPS));
                output.AppendLine(String.Format("FPS: {0}", FPS));
                output.AppendLine(String.Format("AgentsInView: {0}", AgentsInView));
                output.AppendLine(String.Format("Ping: {0}", Ping));
                output.AppendLine(String.Format("MetersTraveled: {0}", MetersTraveled));
                output.AppendLine(String.Format("RegionsVisited: {0}", RegionsVisited));
                output.AppendLine(String.Format("SysRAM: {0}", SysRAM));
                Helpers.FieldToString(output, SysOS, "SysOS");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, SysCPU, "SysCPU");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, SysGPU, "SysGPU");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("viewerstats_downloadtotals")]
        public class DownloadTotalsBlock
        {
            public uint World;
            public uint Objects;
            public uint Textures;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public DownloadTotalsBlock() { }
            public DownloadTotalsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    World = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Objects = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Textures = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(World % 256);
                bytes[i++] = (byte)((World >> 8) % 256);
                bytes[i++] = (byte)((World >> 16) % 256);
                bytes[i++] = (byte)((World >> 24) % 256);
                bytes[i++] = (byte)(Objects % 256);
                bytes[i++] = (byte)((Objects >> 8) % 256);
                bytes[i++] = (byte)((Objects >> 16) % 256);
                bytes[i++] = (byte)((Objects >> 24) % 256);
                bytes[i++] = (byte)(Textures % 256);
                bytes[i++] = (byte)((Textures >> 8) % 256);
                bytes[i++] = (byte)((Textures >> 16) % 256);
                bytes[i++] = (byte)((Textures >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DownloadTotals --");
                output.AppendLine(String.Format("World: {0}", World));
                output.AppendLine(String.Format("Objects: {0}", Objects));
                output.Append(String.Format("Textures: {0}", Textures));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("viewerstats_netstats")]
        public class NetStatsBlock
        {
            public uint Bytes;
            public uint Packets;
            public uint Compressed;
            public uint Savings;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public NetStatsBlock() { }
            public NetStatsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Bytes = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Packets = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Compressed = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Savings = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Bytes % 256);
                bytes[i++] = (byte)((Bytes >> 8) % 256);
                bytes[i++] = (byte)((Bytes >> 16) % 256);
                bytes[i++] = (byte)((Bytes >> 24) % 256);
                bytes[i++] = (byte)(Packets % 256);
                bytes[i++] = (byte)((Packets >> 8) % 256);
                bytes[i++] = (byte)((Packets >> 16) % 256);
                bytes[i++] = (byte)((Packets >> 24) % 256);
                bytes[i++] = (byte)(Compressed % 256);
                bytes[i++] = (byte)((Compressed >> 8) % 256);
                bytes[i++] = (byte)((Compressed >> 16) % 256);
                bytes[i++] = (byte)((Compressed >> 24) % 256);
                bytes[i++] = (byte)(Savings % 256);
                bytes[i++] = (byte)((Savings >> 8) % 256);
                bytes[i++] = (byte)((Savings >> 16) % 256);
                bytes[i++] = (byte)((Savings >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- NetStats --");
                output.AppendLine(String.Format("Bytes: {0}", Bytes));
                output.AppendLine(String.Format("Packets: {0}", Packets));
                output.AppendLine(String.Format("Compressed: {0}", Compressed));
                output.Append(String.Format("Savings: {0}", Savings));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("viewerstats_failstats")]
        public class FailStatsBlock
        {
            public uint SendPacket;
            public uint Dropped;
            public uint Resent;
            public uint FailedResends;
            public uint OffCircuit;
            public uint Invalid;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public FailStatsBlock() { }
            public FailStatsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SendPacket = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Dropped = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Resent = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    FailedResends = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OffCircuit = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Invalid = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(SendPacket % 256);
                bytes[i++] = (byte)((SendPacket >> 8) % 256);
                bytes[i++] = (byte)((SendPacket >> 16) % 256);
                bytes[i++] = (byte)((SendPacket >> 24) % 256);
                bytes[i++] = (byte)(Dropped % 256);
                bytes[i++] = (byte)((Dropped >> 8) % 256);
                bytes[i++] = (byte)((Dropped >> 16) % 256);
                bytes[i++] = (byte)((Dropped >> 24) % 256);
                bytes[i++] = (byte)(Resent % 256);
                bytes[i++] = (byte)((Resent >> 8) % 256);
                bytes[i++] = (byte)((Resent >> 16) % 256);
                bytes[i++] = (byte)((Resent >> 24) % 256);
                bytes[i++] = (byte)(FailedResends % 256);
                bytes[i++] = (byte)((FailedResends >> 8) % 256);
                bytes[i++] = (byte)((FailedResends >> 16) % 256);
                bytes[i++] = (byte)((FailedResends >> 24) % 256);
                bytes[i++] = (byte)(OffCircuit % 256);
                bytes[i++] = (byte)((OffCircuit >> 8) % 256);
                bytes[i++] = (byte)((OffCircuit >> 16) % 256);
                bytes[i++] = (byte)((OffCircuit >> 24) % 256);
                bytes[i++] = (byte)(Invalid % 256);
                bytes[i++] = (byte)((Invalid >> 8) % 256);
                bytes[i++] = (byte)((Invalid >> 16) % 256);
                bytes[i++] = (byte)((Invalid >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FailStats --");
                output.AppendLine(String.Format("SendPacket: {0}", SendPacket));
                output.AppendLine(String.Format("Dropped: {0}", Dropped));
                output.AppendLine(String.Format("Resent: {0}", Resent));
                output.AppendLine(String.Format("FailedResends: {0}", FailedResends));
                output.AppendLine(String.Format("OffCircuit: {0}", OffCircuit));
                output.Append(String.Format("Invalid: {0}", Invalid));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("viewerstats_miscstats")]
        public class MiscStatsBlock
        {
            public uint Type;
            public double Value;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public MiscStatsBlock() { }
            public MiscStatsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Type = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 8);
                    Value = BitConverter.ToDouble(bytes, i); i += 8;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(Type % 256);
                bytes[i++] = (byte)((Type >> 8) % 256);
                bytes[i++] = (byte)((Type >> 16) % 256);
                bytes[i++] = (byte)((Type >> 24) % 256);
                ba = BitConverter.GetBytes(Value);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 8); }
                Buffer.BlockCopy(ba, 0, bytes, i, 8); i += 8;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MiscStats --");
                output.AppendLine(String.Format("Type: {0}", Type));
                output.Append(String.Format("Value: {0}", Value));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ViewerStats; } }
        public AgentDataBlock AgentData;
        public DownloadTotalsBlock DownloadTotals;
        public NetStatsBlock[] NetStats;
        public FailStatsBlock FailStats;
        public MiscStatsBlock[] MiscStats;

        public ViewerStatsPacket()
        {
            Header = new LowHeader();
            Header.ID = 131;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            DownloadTotals = new DownloadTotalsBlock();
            NetStats = new NetStatsBlock[2];
            FailStats = new FailStatsBlock();
            MiscStats = new MiscStatsBlock[0];
        }

        public ViewerStatsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            DownloadTotals = new DownloadTotalsBlock(bytes, ref i);
            NetStats = new NetStatsBlock[2];
            for (int j = 0; j < 2; j++)
            { NetStats[j] = new NetStatsBlock(bytes, ref i); }
            FailStats = new FailStatsBlock(bytes, ref i);
            int count = (int)bytes[i++];
            MiscStats = new MiscStatsBlock[count];
            for (int j = 0; j < count; j++)
            { MiscStats[j] = new MiscStatsBlock(bytes, ref i); }
        }

        public ViewerStatsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            DownloadTotals = new DownloadTotalsBlock(bytes, ref i);
            NetStats = new NetStatsBlock[2];
            for (int j = 0; j < 2; j++)
            { NetStats[j] = new NetStatsBlock(bytes, ref i); }
            FailStats = new FailStatsBlock(bytes, ref i);
            int count = (int)bytes[i++];
            MiscStats = new MiscStatsBlock[count];
            for (int j = 0; j < count; j++)
            { MiscStats[j] = new MiscStatsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += DownloadTotals.Length;            length += FailStats.Length;;
            for (int j = 0; j < 2; j++) { length += NetStats[j].Length; }
            length++;
            for (int j = 0; j < MiscStats.Length; j++) { length += MiscStats[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            DownloadTotals.ToBytes(bytes, ref i);
            for (int j = 0; j < 2; j++) { NetStats[j].ToBytes(bytes, ref i); }
            FailStats.ToBytes(bytes, ref i);
            bytes[i++] = (byte)MiscStats.Length;
            for (int j = 0; j < MiscStats.Length; j++) { MiscStats[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ViewerStats ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += DownloadTotals.ToString() + Environment.NewLine;
            for (int j = 0; j < 2; j++)
            {
                output += NetStats[j].ToString() + Environment.NewLine;
            }
                output += FailStats.ToString() + Environment.NewLine;
            for (int j = 0; j < MiscStats.Length; j++)
            {
                output += MiscStats[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ScriptAnswerYesPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptansweryes_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("scriptansweryes_data")]
        public class DataBlock
        {
            public LLUUID TaskID;
            public LLUUID ItemID;
            public int Questions;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TaskID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                    Questions = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Questions % 256);
                bytes[i++] = (byte)((Questions >> 8) % 256);
                bytes[i++] = (byte)((Questions >> 16) % 256);
                bytes[i++] = (byte)((Questions >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TaskID: {0}", TaskID));
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("Questions: {0}", Questions));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptAnswerYes; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ScriptAnswerYesPacket()
        {
            Header = new LowHeader();
            Header.ID = 132;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ScriptAnswerYesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ScriptAnswerYesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptAnswerYes ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UserReportPacket : Packet
    {
        /// <exclude/>
        [XmlType("userreport_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("userreport_reportdata")]
        public class ReportDataBlock
        {
            public byte ReportType;
            public byte Category;
            public LLVector3 Position;
            public byte CheckFlags;
            public LLUUID ScreenshotID;
            public LLUUID ObjectID;
            public LLUUID AbuserID;
            private byte[] _abuseregionname;
            public byte[] AbuseRegionName
            {
                get { return _abuseregionname; }
                set
                {
                    if (value == null) { _abuseregionname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _abuseregionname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _abuseregionname, 0, value.Length); }
                }
            }
            public LLUUID AbuseRegionID;
            private byte[] _summary;
            public byte[] Summary
            {
                get { return _summary; }
                set
                {
                    if (value == null) { _summary = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _summary = new byte[value.Length]; Buffer.BlockCopy(value, 0, _summary, 0, value.Length); }
                }
            }
            private byte[] _details;
            public byte[] Details
            {
                get { return _details; }
                set
                {
                    if (value == null) { _details = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _details = new byte[value.Length]; Buffer.BlockCopy(value, 0, _details, 0, value.Length); }
                }
            }
            private byte[] _versionstring;
            public byte[] VersionString
            {
                get { return _versionstring; }
                set
                {
                    if (value == null) { _versionstring = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _versionstring = new byte[value.Length]; Buffer.BlockCopy(value, 0, _versionstring, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 79;
                    if (AbuseRegionName != null) { length += 1 + AbuseRegionName.Length; }
                    if (Summary != null) { length += 1 + Summary.Length; }
                    if (Details != null) { length += 2 + Details.Length; }
                    if (VersionString != null) { length += 1 + VersionString.Length; }
                    return length;
                }
            }

            public ReportDataBlock() { }
            public ReportDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ReportType = (byte)bytes[i++];
                    Category = (byte)bytes[i++];
                    Position = new LLVector3(bytes, i); i += 12;
                    CheckFlags = (byte)bytes[i++];
                    ScreenshotID = new LLUUID(bytes, i); i += 16;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    AbuserID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _abuseregionname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _abuseregionname, 0, length); i += length;
                    AbuseRegionID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _summary = new byte[length];
                    Buffer.BlockCopy(bytes, i, _summary, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _details = new byte[length];
                    Buffer.BlockCopy(bytes, i, _details, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _versionstring = new byte[length];
                    Buffer.BlockCopy(bytes, i, _versionstring, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = ReportType;
                bytes[i++] = Category;
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = CheckFlags;
                Buffer.BlockCopy(ScreenshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AbuserID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(AbuseRegionName == null) { Console.WriteLine("Warning: AbuseRegionName is null, in " + this.GetType()); }
                bytes[i++] = (byte)AbuseRegionName.Length;
                Buffer.BlockCopy(AbuseRegionName, 0, bytes, i, AbuseRegionName.Length); i += AbuseRegionName.Length;
                Buffer.BlockCopy(AbuseRegionID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Summary == null) { Console.WriteLine("Warning: Summary is null, in " + this.GetType()); }
                bytes[i++] = (byte)Summary.Length;
                Buffer.BlockCopy(Summary, 0, bytes, i, Summary.Length); i += Summary.Length;
                if(Details == null) { Console.WriteLine("Warning: Details is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Details.Length % 256);
                bytes[i++] = (byte)((Details.Length >> 8) % 256);
                Buffer.BlockCopy(Details, 0, bytes, i, Details.Length); i += Details.Length;
                if(VersionString == null) { Console.WriteLine("Warning: VersionString is null, in " + this.GetType()); }
                bytes[i++] = (byte)VersionString.Length;
                Buffer.BlockCopy(VersionString, 0, bytes, i, VersionString.Length); i += VersionString.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ReportData --");
                output.AppendLine(String.Format("ReportType: {0}", ReportType));
                output.AppendLine(String.Format("Category: {0}", Category));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.AppendLine(String.Format("CheckFlags: {0}", CheckFlags));
                output.AppendLine(String.Format("ScreenshotID: {0}", ScreenshotID));
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("AbuserID: {0}", AbuserID));
                Helpers.FieldToString(output, AbuseRegionName, "AbuseRegionName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("AbuseRegionID: {0}", AbuseRegionID));
                Helpers.FieldToString(output, Summary, "Summary");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Details, "Details");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, VersionString, "VersionString");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UserReport; } }
        public AgentDataBlock AgentData;
        public ReportDataBlock ReportData;

        public UserReportPacket()
        {
            Header = new LowHeader();
            Header.ID = 133;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ReportData = new ReportDataBlock();
        }

        public UserReportPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ReportData = new ReportDataBlock(bytes, ref i);
        }

        public UserReportPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ReportData = new ReportDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ReportData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ReportData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UserReport ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ReportData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AlertMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("alertmessage_alertdata")]
        public class AlertDataBlock
        {
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Message != null) { length += 1 + Message.Length; }
                    return length;
                }
            }

            public AlertDataBlock() { }
            public AlertDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)Message.Length;
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AlertData --");
                Helpers.FieldToString(output, Message, "Message");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AlertMessage; } }
        public AlertDataBlock AlertData;

        public AlertMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 134;
            Header.Reliable = true;
            AlertData = new AlertDataBlock();
        }

        public AlertMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AlertData = new AlertDataBlock(bytes, ref i);
        }

        public AlertMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AlertData = new AlertDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AlertData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AlertData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AlertMessage ---" + Environment.NewLine;
                output += AlertData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentAlertMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentalertmessage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentalertmessage_alertdata")]
        public class AlertDataBlock
        {
            public bool Modal;
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 1;
                    if (Message != null) { length += 1 + Message.Length; }
                    return length;
                }
            }

            public AlertDataBlock() { }
            public AlertDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    Modal = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((Modal) ? 1 : 0);
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)Message.Length;
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AlertData --");
                output.AppendLine(String.Format("Modal: {0}", Modal));
                Helpers.FieldToString(output, Message, "Message");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentAlertMessage; } }
        public AgentDataBlock AgentData;
        public AlertDataBlock AlertData;

        public AgentAlertMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 135;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            AlertData = new AlertDataBlock();
        }

        public AgentAlertMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            AlertData = new AlertDataBlock(bytes, ref i);
        }

        public AgentAlertMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            AlertData = new AlertDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += AlertData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            AlertData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentAlertMessage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += AlertData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MeanCollisionAlertPacket : Packet
    {
        /// <exclude/>
        [XmlType("meancollisionalert_meancollision")]
        public class MeanCollisionBlock
        {
            public LLUUID Victim;
            public LLUUID Perp;
            public uint Time;
            public float Mag;
            public byte Type;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 41;
                }
            }

            public MeanCollisionBlock() { }
            public MeanCollisionBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Victim = new LLUUID(bytes, i); i += 16;
                    Perp = new LLUUID(bytes, i); i += 16;
                    Time = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Mag = BitConverter.ToSingle(bytes, i); i += 4;
                    Type = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(Victim.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Perp.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Time % 256);
                bytes[i++] = (byte)((Time >> 8) % 256);
                bytes[i++] = (byte)((Time >> 16) % 256);
                bytes[i++] = (byte)((Time >> 24) % 256);
                ba = BitConverter.GetBytes(Mag);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = Type;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MeanCollision --");
                output.AppendLine(String.Format("Victim: {0}", Victim));
                output.AppendLine(String.Format("Perp: {0}", Perp));
                output.AppendLine(String.Format("Time: {0}", Time));
                output.AppendLine(String.Format("Mag: {0}", Mag));
                output.Append(String.Format("Type: {0}", Type));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MeanCollisionAlert; } }
        public MeanCollisionBlock[] MeanCollision;

        public MeanCollisionAlertPacket()
        {
            Header = new LowHeader();
            Header.ID = 136;
            Header.Reliable = true;
            MeanCollision = new MeanCollisionBlock[0];
        }

        public MeanCollisionAlertPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            MeanCollision = new MeanCollisionBlock[count];
            for (int j = 0; j < count; j++)
            { MeanCollision[j] = new MeanCollisionBlock(bytes, ref i); }
        }

        public MeanCollisionAlertPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            MeanCollision = new MeanCollisionBlock[count];
            for (int j = 0; j < count; j++)
            { MeanCollision[j] = new MeanCollisionBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < MeanCollision.Length; j++) { length += MeanCollision[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)MeanCollision.Length;
            for (int j = 0; j < MeanCollision.Length; j++) { MeanCollision[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MeanCollisionAlert ---" + Environment.NewLine;
            for (int j = 0; j < MeanCollision.Length; j++)
            {
                output += MeanCollision[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ViewerFrozenMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("viewerfrozenmessage_frozendata")]
        public class FrozenDataBlock
        {
            public bool Data;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public FrozenDataBlock() { }
            public FrozenDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Data = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((Data) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FrozenData --");
                output.Append(String.Format("Data: {0}", Data));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ViewerFrozenMessage; } }
        public FrozenDataBlock FrozenData;

        public ViewerFrozenMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 137;
            Header.Reliable = true;
            FrozenData = new FrozenDataBlock();
        }

        public ViewerFrozenMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            FrozenData = new FrozenDataBlock(bytes, ref i);
        }

        public ViewerFrozenMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            FrozenData = new FrozenDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += FrozenData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            FrozenData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ViewerFrozenMessage ---" + Environment.NewLine;
                output += FrozenData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class HealthMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("healthmessage_healthdata")]
        public class HealthDataBlock
        {
            public float Health;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public HealthDataBlock() { }
            public HealthDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Health = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                ba = BitConverter.GetBytes(Health);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HealthData --");
                output.Append(String.Format("Health: {0}", Health));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.HealthMessage; } }
        public HealthDataBlock HealthData;

        public HealthMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 138;
            Header.Reliable = true;
            HealthData = new HealthDataBlock();
        }

        public HealthMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            HealthData = new HealthDataBlock(bytes, ref i);
        }

        public HealthMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            HealthData = new HealthDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += HealthData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            HealthData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- HealthMessage ---" + Environment.NewLine;
                output += HealthData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ChatFromSimulatorPacket : Packet
    {
        /// <exclude/>
        [XmlType("chatfromsimulator_chatdata")]
        public class ChatDataBlock
        {
            private byte[] _fromname;
            public byte[] FromName
            {
                get { return _fromname; }
                set
                {
                    if (value == null) { _fromname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _fromname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _fromname, 0, value.Length); }
                }
            }
            public LLUUID SourceID;
            public LLUUID OwnerID;
            public byte SourceType;
            public byte ChatType;
            public byte Audible;
            public LLVector3 Position;
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 47;
                    if (FromName != null) { length += 1 + FromName.Length; }
                    if (Message != null) { length += 2 + Message.Length; }
                    return length;
                }
            }

            public ChatDataBlock() { }
            public ChatDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _fromname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _fromname, 0, length); i += length;
                    SourceID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    SourceType = (byte)bytes[i++];
                    ChatType = (byte)bytes[i++];
                    Audible = (byte)bytes[i++];
                    Position = new LLVector3(bytes, i); i += 12;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(FromName == null) { Console.WriteLine("Warning: FromName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FromName.Length;
                Buffer.BlockCopy(FromName, 0, bytes, i, FromName.Length); i += FromName.Length;
                Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = SourceType;
                bytes[i++] = ChatType;
                bytes[i++] = Audible;
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Message.Length % 256);
                bytes[i++] = (byte)((Message.Length >> 8) % 256);
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ChatData --");
                Helpers.FieldToString(output, FromName, "FromName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SourceID: {0}", SourceID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("SourceType: {0}", SourceType));
                output.AppendLine(String.Format("ChatType: {0}", ChatType));
                output.AppendLine(String.Format("Audible: {0}", Audible));
                output.AppendLine(String.Format("Position: {0}", Position));
                Helpers.FieldToString(output, Message, "Message");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChatFromSimulator; } }
        public ChatDataBlock ChatData;

        public ChatFromSimulatorPacket()
        {
            Header = new LowHeader();
            Header.ID = 139;
            Header.Reliable = true;
            ChatData = new ChatDataBlock();
        }

        public ChatFromSimulatorPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ChatData = new ChatDataBlock(bytes, ref i);
        }

        public ChatFromSimulatorPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ChatData = new ChatDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ChatData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ChatData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChatFromSimulator ---" + Environment.NewLine;
                output += ChatData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SimStatsPacket : Packet
    {
        /// <exclude/>
        [XmlType("simstats_region")]
        public class RegionBlock
        {
            public uint RegionX;
            public uint RegionY;
            public uint RegionFlags;
            public uint ObjectCapacity;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public RegionBlock() { }
            public RegionBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionX = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RegionY = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ObjectCapacity = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionX % 256);
                bytes[i++] = (byte)((RegionX >> 8) % 256);
                bytes[i++] = (byte)((RegionX >> 16) % 256);
                bytes[i++] = (byte)((RegionX >> 24) % 256);
                bytes[i++] = (byte)(RegionY % 256);
                bytes[i++] = (byte)((RegionY >> 8) % 256);
                bytes[i++] = (byte)((RegionY >> 16) % 256);
                bytes[i++] = (byte)((RegionY >> 24) % 256);
                bytes[i++] = (byte)(RegionFlags % 256);
                bytes[i++] = (byte)((RegionFlags >> 8) % 256);
                bytes[i++] = (byte)((RegionFlags >> 16) % 256);
                bytes[i++] = (byte)((RegionFlags >> 24) % 256);
                bytes[i++] = (byte)(ObjectCapacity % 256);
                bytes[i++] = (byte)((ObjectCapacity >> 8) % 256);
                bytes[i++] = (byte)((ObjectCapacity >> 16) % 256);
                bytes[i++] = (byte)((ObjectCapacity >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Region --");
                output.AppendLine(String.Format("RegionX: {0}", RegionX));
                output.AppendLine(String.Format("RegionY: {0}", RegionY));
                output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
                output.Append(String.Format("ObjectCapacity: {0}", ObjectCapacity));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("simstats_stat")]
        public class StatBlock
        {
            public uint StatID;
            public float StatValue;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public StatBlock() { }
            public StatBlock(byte[] bytes, ref int i)
            {
                try
                {
                    StatID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    StatValue = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(StatID % 256);
                bytes[i++] = (byte)((StatID >> 8) % 256);
                bytes[i++] = (byte)((StatID >> 16) % 256);
                bytes[i++] = (byte)((StatID >> 24) % 256);
                ba = BitConverter.GetBytes(StatValue);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Stat --");
                output.AppendLine(String.Format("StatID: {0}", StatID));
                output.Append(String.Format("StatValue: {0}", StatValue));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SimStats; } }
        public RegionBlock Region;
        public StatBlock[] Stat;

        public SimStatsPacket()
        {
            Header = new LowHeader();
            Header.ID = 140;
            Header.Reliable = true;
            Region = new RegionBlock();
            Stat = new StatBlock[0];
        }

        public SimStatsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Region = new RegionBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Stat = new StatBlock[count];
            for (int j = 0; j < count; j++)
            { Stat[j] = new StatBlock(bytes, ref i); }
        }

        public SimStatsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Region = new RegionBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Stat = new StatBlock[count];
            for (int j = 0; j < count; j++)
            { Stat[j] = new StatBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Region.Length;;
            length++;
            for (int j = 0; j < Stat.Length; j++) { length += Stat[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Region.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Stat.Length;
            for (int j = 0; j < Stat.Length; j++) { Stat[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SimStats ---" + Environment.NewLine;
                output += Region.ToString() + Environment.NewLine;
            for (int j = 0; j < Stat.Length; j++)
            {
                output += Stat[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RequestRegionInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("requestregioninfo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestRegionInfo; } }
        public AgentDataBlock AgentData;

        public RequestRegionInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 141;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public RequestRegionInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public RequestRegionInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestRegionInfo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RegionInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("regioninfo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("regioninfo_regioninfo")]
        public class RegionInfoBlock
        {
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public uint EstateID;
            public uint ParentEstateID;
            public uint RegionFlags;
            public byte SimAccess;
            public byte MaxAgents;
            public float BillableFactor;
            public float ObjectBonusFactor;
            public float WaterHeight;
            public float TerrainRaiseLimit;
            public float TerrainLowerLimit;
            public int PricePerMeter;
            public int RedirectGridX;
            public int RedirectGridY;
            public bool UseEstateSun;
            public float SunHour;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 51;
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public RegionInfoBlock() { }
            public RegionInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParentEstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SimAccess = (byte)bytes[i++];
                    MaxAgents = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    BillableFactor = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    ObjectBonusFactor = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    WaterHeight = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainRaiseLimit = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainLowerLimit = BitConverter.ToSingle(bytes, i); i += 4;
                    PricePerMeter = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RedirectGridX = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RedirectGridY = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    UseEstateSun = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    SunHour = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                bytes[i++] = (byte)(EstateID % 256);
                bytes[i++] = (byte)((EstateID >> 8) % 256);
                bytes[i++] = (byte)((EstateID >> 16) % 256);
                bytes[i++] = (byte)((EstateID >> 24) % 256);
                bytes[i++] = (byte)(ParentEstateID % 256);
                bytes[i++] = (byte)((ParentEstateID >> 8) % 256);
                bytes[i++] = (byte)((ParentEstateID >> 16) % 256);
                bytes[i++] = (byte)((ParentEstateID >> 24) % 256);
                bytes[i++] = (byte)(RegionFlags % 256);
                bytes[i++] = (byte)((RegionFlags >> 8) % 256);
                bytes[i++] = (byte)((RegionFlags >> 16) % 256);
                bytes[i++] = (byte)((RegionFlags >> 24) % 256);
                bytes[i++] = SimAccess;
                bytes[i++] = MaxAgents;
                ba = BitConverter.GetBytes(BillableFactor);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(ObjectBonusFactor);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(WaterHeight);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainRaiseLimit);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainLowerLimit);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(PricePerMeter % 256);
                bytes[i++] = (byte)((PricePerMeter >> 8) % 256);
                bytes[i++] = (byte)((PricePerMeter >> 16) % 256);
                bytes[i++] = (byte)((PricePerMeter >> 24) % 256);
                bytes[i++] = (byte)(RedirectGridX % 256);
                bytes[i++] = (byte)((RedirectGridX >> 8) % 256);
                bytes[i++] = (byte)((RedirectGridX >> 16) % 256);
                bytes[i++] = (byte)((RedirectGridX >> 24) % 256);
                bytes[i++] = (byte)(RedirectGridY % 256);
                bytes[i++] = (byte)((RedirectGridY >> 8) % 256);
                bytes[i++] = (byte)((RedirectGridY >> 16) % 256);
                bytes[i++] = (byte)((RedirectGridY >> 24) % 256);
                bytes[i++] = (byte)((UseEstateSun) ? 1 : 0);
                ba = BitConverter.GetBytes(SunHour);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionInfo --");
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("EstateID: {0}", EstateID));
                output.AppendLine(String.Format("ParentEstateID: {0}", ParentEstateID));
                output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
                output.AppendLine(String.Format("SimAccess: {0}", SimAccess));
                output.AppendLine(String.Format("MaxAgents: {0}", MaxAgents));
                output.AppendLine(String.Format("BillableFactor: {0}", BillableFactor));
                output.AppendLine(String.Format("ObjectBonusFactor: {0}", ObjectBonusFactor));
                output.AppendLine(String.Format("WaterHeight: {0}", WaterHeight));
                output.AppendLine(String.Format("TerrainRaiseLimit: {0}", TerrainRaiseLimit));
                output.AppendLine(String.Format("TerrainLowerLimit: {0}", TerrainLowerLimit));
                output.AppendLine(String.Format("PricePerMeter: {0}", PricePerMeter));
                output.AppendLine(String.Format("RedirectGridX: {0}", RedirectGridX));
                output.AppendLine(String.Format("RedirectGridY: {0}", RedirectGridY));
                output.AppendLine(String.Format("UseEstateSun: {0}", UseEstateSun));
                output.Append(String.Format("SunHour: {0}", SunHour));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RegionInfo; } }
        public AgentDataBlock AgentData;
        public RegionInfoBlock RegionInfo;

        public RegionInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 142;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RegionInfo = new RegionInfoBlock();
        }

        public RegionInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
        }

        public RegionInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RegionInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RegionInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RegionInfo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RegionInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GodUpdateRegionInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("godupdateregioninfo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("godupdateregioninfo_regioninfo")]
        public class RegionInfoBlock
        {
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public uint EstateID;
            public uint ParentEstateID;
            public uint RegionFlags;
            public float BillableFactor;
            public int PricePerMeter;
            public int RedirectGridX;
            public int RedirectGridY;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public RegionInfoBlock() { }
            public RegionInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParentEstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    BillableFactor = BitConverter.ToSingle(bytes, i); i += 4;
                    PricePerMeter = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RedirectGridX = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RedirectGridY = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                bytes[i++] = (byte)(EstateID % 256);
                bytes[i++] = (byte)((EstateID >> 8) % 256);
                bytes[i++] = (byte)((EstateID >> 16) % 256);
                bytes[i++] = (byte)((EstateID >> 24) % 256);
                bytes[i++] = (byte)(ParentEstateID % 256);
                bytes[i++] = (byte)((ParentEstateID >> 8) % 256);
                bytes[i++] = (byte)((ParentEstateID >> 16) % 256);
                bytes[i++] = (byte)((ParentEstateID >> 24) % 256);
                bytes[i++] = (byte)(RegionFlags % 256);
                bytes[i++] = (byte)((RegionFlags >> 8) % 256);
                bytes[i++] = (byte)((RegionFlags >> 16) % 256);
                bytes[i++] = (byte)((RegionFlags >> 24) % 256);
                ba = BitConverter.GetBytes(BillableFactor);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(PricePerMeter % 256);
                bytes[i++] = (byte)((PricePerMeter >> 8) % 256);
                bytes[i++] = (byte)((PricePerMeter >> 16) % 256);
                bytes[i++] = (byte)((PricePerMeter >> 24) % 256);
                bytes[i++] = (byte)(RedirectGridX % 256);
                bytes[i++] = (byte)((RedirectGridX >> 8) % 256);
                bytes[i++] = (byte)((RedirectGridX >> 16) % 256);
                bytes[i++] = (byte)((RedirectGridX >> 24) % 256);
                bytes[i++] = (byte)(RedirectGridY % 256);
                bytes[i++] = (byte)((RedirectGridY >> 8) % 256);
                bytes[i++] = (byte)((RedirectGridY >> 16) % 256);
                bytes[i++] = (byte)((RedirectGridY >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionInfo --");
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("EstateID: {0}", EstateID));
                output.AppendLine(String.Format("ParentEstateID: {0}", ParentEstateID));
                output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
                output.AppendLine(String.Format("BillableFactor: {0}", BillableFactor));
                output.AppendLine(String.Format("PricePerMeter: {0}", PricePerMeter));
                output.AppendLine(String.Format("RedirectGridX: {0}", RedirectGridX));
                output.Append(String.Format("RedirectGridY: {0}", RedirectGridY));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GodUpdateRegionInfo; } }
        public AgentDataBlock AgentData;
        public RegionInfoBlock RegionInfo;

        public GodUpdateRegionInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 143;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RegionInfo = new RegionInfoBlock();
        }

        public GodUpdateRegionInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
        }

        public GodUpdateRegionInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RegionInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RegionInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GodUpdateRegionInfo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RegionInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class NearestLandingRegionUpdatedPacket : Packet
    {
        /// <exclude/>
        [XmlType("nearestlandingregionupdated_regiondata")]
        public class RegionDataBlock
        {
            public ulong RegionHandle;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public RegionDataBlock() { }
            public RegionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionData --");
                output.Append(String.Format("RegionHandle: {0}", RegionHandle));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.NearestLandingRegionUpdated; } }
        public RegionDataBlock RegionData;

        public NearestLandingRegionUpdatedPacket()
        {
            Header = new LowHeader();
            Header.ID = 146;
            Header.Reliable = true;
            RegionData = new RegionDataBlock();
        }

        public NearestLandingRegionUpdatedPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            RegionData = new RegionDataBlock(bytes, ref i);
        }

        public NearestLandingRegionUpdatedPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RegionData = new RegionDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += RegionData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RegionData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- NearestLandingRegionUpdated ---" + Environment.NewLine;
                output += RegionData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RegionHandshakePacket : Packet
    {
        /// <exclude/>
        [XmlType("regionhandshake_regioninfo")]
        public class RegionInfoBlock
        {
            public uint RegionFlags;
            public byte SimAccess;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLUUID SimOwner;
            public bool IsEstateManager;
            public float WaterHeight;
            public float BillableFactor;
            public LLUUID CacheID;
            public LLUUID TerrainBase0;
            public LLUUID TerrainBase1;
            public LLUUID TerrainBase2;
            public LLUUID TerrainBase3;
            public LLUUID TerrainDetail0;
            public LLUUID TerrainDetail1;
            public LLUUID TerrainDetail2;
            public LLUUID TerrainDetail3;
            public float TerrainStartHeight00;
            public float TerrainStartHeight01;
            public float TerrainStartHeight10;
            public float TerrainStartHeight11;
            public float TerrainHeightRange00;
            public float TerrainHeightRange01;
            public float TerrainHeightRange10;
            public float TerrainHeightRange11;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 206;
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public RegionInfoBlock() { }
            public RegionInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SimAccess = (byte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    SimOwner = new LLUUID(bytes, i); i += 16;
                    IsEstateManager = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    WaterHeight = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    BillableFactor = BitConverter.ToSingle(bytes, i); i += 4;
                    CacheID = new LLUUID(bytes, i); i += 16;
                    TerrainBase0 = new LLUUID(bytes, i); i += 16;
                    TerrainBase1 = new LLUUID(bytes, i); i += 16;
                    TerrainBase2 = new LLUUID(bytes, i); i += 16;
                    TerrainBase3 = new LLUUID(bytes, i); i += 16;
                    TerrainDetail0 = new LLUUID(bytes, i); i += 16;
                    TerrainDetail1 = new LLUUID(bytes, i); i += 16;
                    TerrainDetail2 = new LLUUID(bytes, i); i += 16;
                    TerrainDetail3 = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainStartHeight00 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainStartHeight01 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainStartHeight10 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainStartHeight11 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainHeightRange00 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainHeightRange01 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainHeightRange10 = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    TerrainHeightRange11 = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(RegionFlags % 256);
                bytes[i++] = (byte)((RegionFlags >> 8) % 256);
                bytes[i++] = (byte)((RegionFlags >> 16) % 256);
                bytes[i++] = (byte)((RegionFlags >> 24) % 256);
                bytes[i++] = SimAccess;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(SimOwner.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsEstateManager) ? 1 : 0);
                ba = BitConverter.GetBytes(WaterHeight);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(BillableFactor);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                Buffer.BlockCopy(CacheID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainBase0.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainBase1.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainBase2.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainBase3.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainDetail0.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainDetail1.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainDetail2.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TerrainDetail3.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(TerrainStartHeight00);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainStartHeight01);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainStartHeight10);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainStartHeight11);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainHeightRange00);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainHeightRange01);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainHeightRange10);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(TerrainHeightRange11);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionInfo --");
                output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
                output.AppendLine(String.Format("SimAccess: {0}", SimAccess));
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SimOwner: {0}", SimOwner));
                output.AppendLine(String.Format("IsEstateManager: {0}", IsEstateManager));
                output.AppendLine(String.Format("WaterHeight: {0}", WaterHeight));
                output.AppendLine(String.Format("BillableFactor: {0}", BillableFactor));
                output.AppendLine(String.Format("CacheID: {0}", CacheID));
                output.AppendLine(String.Format("TerrainBase0: {0}", TerrainBase0));
                output.AppendLine(String.Format("TerrainBase1: {0}", TerrainBase1));
                output.AppendLine(String.Format("TerrainBase2: {0}", TerrainBase2));
                output.AppendLine(String.Format("TerrainBase3: {0}", TerrainBase3));
                output.AppendLine(String.Format("TerrainDetail0: {0}", TerrainDetail0));
                output.AppendLine(String.Format("TerrainDetail1: {0}", TerrainDetail1));
                output.AppendLine(String.Format("TerrainDetail2: {0}", TerrainDetail2));
                output.AppendLine(String.Format("TerrainDetail3: {0}", TerrainDetail3));
                output.AppendLine(String.Format("TerrainStartHeight00: {0}", TerrainStartHeight00));
                output.AppendLine(String.Format("TerrainStartHeight01: {0}", TerrainStartHeight01));
                output.AppendLine(String.Format("TerrainStartHeight10: {0}", TerrainStartHeight10));
                output.AppendLine(String.Format("TerrainStartHeight11: {0}", TerrainStartHeight11));
                output.AppendLine(String.Format("TerrainHeightRange00: {0}", TerrainHeightRange00));
                output.AppendLine(String.Format("TerrainHeightRange01: {0}", TerrainHeightRange01));
                output.AppendLine(String.Format("TerrainHeightRange10: {0}", TerrainHeightRange10));
                output.Append(String.Format("TerrainHeightRange11: {0}", TerrainHeightRange11));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("regionhandshake_regioninfo2")]
        public class RegionInfo2Block
        {
            public LLUUID RegionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public RegionInfo2Block() { }
            public RegionInfo2Block(byte[] bytes, ref int i)
            {
                try
                {
                    RegionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionInfo2 --");
                output.Append(String.Format("RegionID: {0}", RegionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RegionHandshake; } }
        public RegionInfoBlock RegionInfo;
        public RegionInfo2Block RegionInfo2;

        public RegionHandshakePacket()
        {
            Header = new LowHeader();
            Header.ID = 148;
            Header.Reliable = true;
            RegionInfo = new RegionInfoBlock();
            RegionInfo2 = new RegionInfo2Block();
        }

        public RegionHandshakePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
            RegionInfo2 = new RegionInfo2Block(bytes, ref i);
        }

        public RegionHandshakePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RegionInfo = new RegionInfoBlock(bytes, ref i);
            RegionInfo2 = new RegionInfo2Block(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += RegionInfo.Length;            length += RegionInfo2.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RegionInfo.ToBytes(bytes, ref i);
            RegionInfo2.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RegionHandshake ---" + Environment.NewLine;
                output += RegionInfo.ToString() + Environment.NewLine;
                output += RegionInfo2.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RegionHandshakeReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("regionhandshakereply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("regionhandshakereply_regioninfo")]
        public class RegionInfoBlock
        {
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public RegionInfoBlock() { }
            public RegionInfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionInfo --");
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RegionHandshakeReply; } }
        public AgentDataBlock AgentData;
        public RegionInfoBlock RegionInfo;

        public RegionHandshakeReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 149;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RegionInfo = new RegionInfoBlock();
        }

        public RegionHandshakeReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
        }

        public RegionHandshakeReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionInfo = new RegionInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RegionInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RegionInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RegionHandshakeReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RegionInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SimulatorViewerTimeMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("simulatorviewertimemessage_timeinfo")]
        public class TimeInfoBlock
        {
            public ulong UsecSinceStart;
            public uint SecPerDay;
            public uint SecPerYear;
            public LLVector3 SunDirection;
            public float SunPhase;
            public LLVector3 SunAngVelocity;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 44;
                }
            }

            public TimeInfoBlock() { }
            public TimeInfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    UsecSinceStart = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    SecPerDay = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SecPerYear = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SunDirection = new LLVector3(bytes, i); i += 12;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    SunPhase = BitConverter.ToSingle(bytes, i); i += 4;
                    SunAngVelocity = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(UsecSinceStart % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 8) % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 16) % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 24) % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 32) % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 40) % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 48) % 256);
                bytes[i++] = (byte)((UsecSinceStart >> 56) % 256);
                bytes[i++] = (byte)(SecPerDay % 256);
                bytes[i++] = (byte)((SecPerDay >> 8) % 256);
                bytes[i++] = (byte)((SecPerDay >> 16) % 256);
                bytes[i++] = (byte)((SecPerDay >> 24) % 256);
                bytes[i++] = (byte)(SecPerYear % 256);
                bytes[i++] = (byte)((SecPerYear >> 8) % 256);
                bytes[i++] = (byte)((SecPerYear >> 16) % 256);
                bytes[i++] = (byte)((SecPerYear >> 24) % 256);
                Buffer.BlockCopy(SunDirection.GetBytes(), 0, bytes, i, 12); i += 12;
                ba = BitConverter.GetBytes(SunPhase);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                Buffer.BlockCopy(SunAngVelocity.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TimeInfo --");
                output.AppendLine(String.Format("UsecSinceStart: {0}", UsecSinceStart));
                output.AppendLine(String.Format("SecPerDay: {0}", SecPerDay));
                output.AppendLine(String.Format("SecPerYear: {0}", SecPerYear));
                output.AppendLine(String.Format("SunDirection: {0}", SunDirection));
                output.AppendLine(String.Format("SunPhase: {0}", SunPhase));
                output.Append(String.Format("SunAngVelocity: {0}", SunAngVelocity));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SimulatorViewerTimeMessage; } }
        public TimeInfoBlock TimeInfo;

        public SimulatorViewerTimeMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 150;
            Header.Reliable = true;
            TimeInfo = new TimeInfoBlock();
        }

        public SimulatorViewerTimeMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TimeInfo = new TimeInfoBlock(bytes, ref i);
        }

        public SimulatorViewerTimeMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TimeInfo = new TimeInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TimeInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TimeInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SimulatorViewerTimeMessage ---" + Environment.NewLine;
                output += TimeInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EnableSimulatorPacket : Packet
    {
        /// <exclude/>
        [XmlType("enablesimulator_simulatorinfo")]
        public class SimulatorInfoBlock
        {
            public ulong Handle;
            public uint IP;
            public ushort Port;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 14;
                }
            }

            public SimulatorInfoBlock() { }
            public SimulatorInfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Handle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    IP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Port = (ushort)((bytes[i++] << 8) + bytes[i++]);
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Handle % 256);
                bytes[i++] = (byte)((Handle >> 8) % 256);
                bytes[i++] = (byte)((Handle >> 16) % 256);
                bytes[i++] = (byte)((Handle >> 24) % 256);
                bytes[i++] = (byte)((Handle >> 32) % 256);
                bytes[i++] = (byte)((Handle >> 40) % 256);
                bytes[i++] = (byte)((Handle >> 48) % 256);
                bytes[i++] = (byte)((Handle >> 56) % 256);
                bytes[i++] = (byte)(IP % 256);
                bytes[i++] = (byte)((IP >> 8) % 256);
                bytes[i++] = (byte)((IP >> 16) % 256);
                bytes[i++] = (byte)((IP >> 24) % 256);
                bytes[i++] = (byte)((Port >> 8) % 256);
                bytes[i++] = (byte)(Port % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SimulatorInfo --");
                output.AppendLine(String.Format("Handle: {0}", Handle));
                output.AppendLine(String.Format("IP: {0}", IP));
                output.Append(String.Format("Port: {0}", Port));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EnableSimulator; } }
        public SimulatorInfoBlock SimulatorInfo;

        public EnableSimulatorPacket()
        {
            Header = new LowHeader();
            Header.ID = 151;
            Header.Reliable = true;
            SimulatorInfo = new SimulatorInfoBlock();
        }

        public EnableSimulatorPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            SimulatorInfo = new SimulatorInfoBlock(bytes, ref i);
        }

        public EnableSimulatorPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            SimulatorInfo = new SimulatorInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += SimulatorInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            SimulatorInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EnableSimulator ---" + Environment.NewLine;
                output += SimulatorInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DisableSimulatorPacket : Packet
    {
        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DisableSimulator; } }

        public DisableSimulatorPacket()
        {
            Header = new LowHeader();
            Header.ID = 152;
            Header.Reliable = true;
        }

        public DisableSimulatorPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
        }

        public DisableSimulatorPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DisableSimulator ---" + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TransferRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("transferrequest_transferinfo")]
        public class TransferInfoBlock
        {
            public LLUUID TransferID;
            public int ChannelType;
            public int SourceType;
            public float Priority;
            private byte[] _params;
            public byte[] Params
            {
                get { return _params; }
                set
                {
                    if (value == null) { _params = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _params = new byte[value.Length]; Buffer.BlockCopy(value, 0, _params, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (Params != null) { length += 2 + Params.Length; }
                    return length;
                }
            }

            public TransferInfoBlock() { }
            public TransferInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TransferID = new LLUUID(bytes, i); i += 16;
                    ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SourceType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Priority = BitConverter.ToSingle(bytes, i); i += 4;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _params = new byte[length];
                    Buffer.BlockCopy(bytes, i, _params, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ChannelType % 256);
                bytes[i++] = (byte)((ChannelType >> 8) % 256);
                bytes[i++] = (byte)((ChannelType >> 16) % 256);
                bytes[i++] = (byte)((ChannelType >> 24) % 256);
                bytes[i++] = (byte)(SourceType % 256);
                bytes[i++] = (byte)((SourceType >> 8) % 256);
                bytes[i++] = (byte)((SourceType >> 16) % 256);
                bytes[i++] = (byte)((SourceType >> 24) % 256);
                ba = BitConverter.GetBytes(Priority);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                if(Params == null) { Console.WriteLine("Warning: Params is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Params.Length % 256);
                bytes[i++] = (byte)((Params.Length >> 8) % 256);
                Buffer.BlockCopy(Params, 0, bytes, i, Params.Length); i += Params.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransferInfo --");
                output.AppendLine(String.Format("TransferID: {0}", TransferID));
                output.AppendLine(String.Format("ChannelType: {0}", ChannelType));
                output.AppendLine(String.Format("SourceType: {0}", SourceType));
                output.AppendLine(String.Format("Priority: {0}", Priority));
                Helpers.FieldToString(output, Params, "Params");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TransferRequest; } }
        public TransferInfoBlock TransferInfo;

        public TransferRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 153;
            Header.Reliable = true;
            TransferInfo = new TransferInfoBlock();
        }

        public TransferRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TransferInfo = new TransferInfoBlock(bytes, ref i);
        }

        public TransferRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TransferInfo = new TransferInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TransferInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TransferInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TransferRequest ---" + Environment.NewLine;
                output += TransferInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TransferInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("transferinfo_transferinfo")]
        public class TransferInfoBlock
        {
            public LLUUID TransferID;
            public int ChannelType;
            public int TargetType;
            public int Status;
            public int Size;
            private byte[] _params;
            public byte[] Params
            {
                get { return _params; }
                set
                {
                    if (value == null) { _params = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _params = new byte[value.Length]; Buffer.BlockCopy(value, 0, _params, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 32;
                    if (Params != null) { length += 2 + Params.Length; }
                    return length;
                }
            }

            public TransferInfoBlock() { }
            public TransferInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TransferID = new LLUUID(bytes, i); i += 16;
                    ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TargetType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Status = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Size = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _params = new byte[length];
                    Buffer.BlockCopy(bytes, i, _params, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ChannelType % 256);
                bytes[i++] = (byte)((ChannelType >> 8) % 256);
                bytes[i++] = (byte)((ChannelType >> 16) % 256);
                bytes[i++] = (byte)((ChannelType >> 24) % 256);
                bytes[i++] = (byte)(TargetType % 256);
                bytes[i++] = (byte)((TargetType >> 8) % 256);
                bytes[i++] = (byte)((TargetType >> 16) % 256);
                bytes[i++] = (byte)((TargetType >> 24) % 256);
                bytes[i++] = (byte)(Status % 256);
                bytes[i++] = (byte)((Status >> 8) % 256);
                bytes[i++] = (byte)((Status >> 16) % 256);
                bytes[i++] = (byte)((Status >> 24) % 256);
                bytes[i++] = (byte)(Size % 256);
                bytes[i++] = (byte)((Size >> 8) % 256);
                bytes[i++] = (byte)((Size >> 16) % 256);
                bytes[i++] = (byte)((Size >> 24) % 256);
                if(Params == null) { Console.WriteLine("Warning: Params is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Params.Length % 256);
                bytes[i++] = (byte)((Params.Length >> 8) % 256);
                Buffer.BlockCopy(Params, 0, bytes, i, Params.Length); i += Params.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransferInfo --");
                output.AppendLine(String.Format("TransferID: {0}", TransferID));
                output.AppendLine(String.Format("ChannelType: {0}", ChannelType));
                output.AppendLine(String.Format("TargetType: {0}", TargetType));
                output.AppendLine(String.Format("Status: {0}", Status));
                output.AppendLine(String.Format("Size: {0}", Size));
                Helpers.FieldToString(output, Params, "Params");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TransferInfo; } }
        public TransferInfoBlock TransferInfo;

        public TransferInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 154;
            Header.Reliable = true;
            TransferInfo = new TransferInfoBlock();
        }

        public TransferInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TransferInfo = new TransferInfoBlock(bytes, ref i);
        }

        public TransferInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TransferInfo = new TransferInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TransferInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TransferInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TransferInfo ---" + Environment.NewLine;
                output += TransferInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TransferAbortPacket : Packet
    {
        /// <exclude/>
        [XmlType("transferabort_transferinfo")]
        public class TransferInfoBlock
        {
            public LLUUID TransferID;
            public int ChannelType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public TransferInfoBlock() { }
            public TransferInfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransferID = new LLUUID(bytes, i); i += 16;
                    ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ChannelType % 256);
                bytes[i++] = (byte)((ChannelType >> 8) % 256);
                bytes[i++] = (byte)((ChannelType >> 16) % 256);
                bytes[i++] = (byte)((ChannelType >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransferInfo --");
                output.AppendLine(String.Format("TransferID: {0}", TransferID));
                output.Append(String.Format("ChannelType: {0}", ChannelType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TransferAbort; } }
        public TransferInfoBlock TransferInfo;

        public TransferAbortPacket()
        {
            Header = new LowHeader();
            Header.ID = 155;
            Header.Reliable = true;
            TransferInfo = new TransferInfoBlock();
        }

        public TransferAbortPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TransferInfo = new TransferInfoBlock(bytes, ref i);
        }

        public TransferAbortPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TransferInfo = new TransferInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TransferInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TransferInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TransferAbort ---" + Environment.NewLine;
                output += TransferInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RequestXferPacket : Packet
    {
        /// <exclude/>
        [XmlType("requestxfer_xferid")]
        public class XferIDBlock
        {
            public ulong ID;
            private byte[] _filename;
            public byte[] Filename
            {
                get { return _filename; }
                set
                {
                    if (value == null) { _filename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
                }
            }
            public byte FilePath;
            public bool DeleteOnCompletion;
            public bool UseBigPackets;
            public LLUUID VFileID;
            public short VFileType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 29;
                    if (Filename != null) { length += 1 + Filename.Length; }
                    return length;
                }
            }

            public XferIDBlock() { }
            public XferIDBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    length = (ushort)bytes[i++];
                    _filename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
                    FilePath = (byte)bytes[i++];
                    DeleteOnCompletion = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    UseBigPackets = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    VFileID = new LLUUID(bytes, i); i += 16;
                    VFileType = (short)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
                bytes[i++] = (byte)((ID >> 32) % 256);
                bytes[i++] = (byte)((ID >> 40) % 256);
                bytes[i++] = (byte)((ID >> 48) % 256);
                bytes[i++] = (byte)((ID >> 56) % 256);
                if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
                bytes[i++] = (byte)Filename.Length;
                Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
                bytes[i++] = FilePath;
                bytes[i++] = (byte)((DeleteOnCompletion) ? 1 : 0);
                bytes[i++] = (byte)((UseBigPackets) ? 1 : 0);
                Buffer.BlockCopy(VFileID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(VFileType % 256);
                bytes[i++] = (byte)((VFileType >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- XferID --");
                output.AppendLine(String.Format("ID: {0}", ID));
                Helpers.FieldToString(output, Filename, "Filename");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("FilePath: {0}", FilePath));
                output.AppendLine(String.Format("DeleteOnCompletion: {0}", DeleteOnCompletion));
                output.AppendLine(String.Format("UseBigPackets: {0}", UseBigPackets));
                output.AppendLine(String.Format("VFileID: {0}", VFileID));
                output.Append(String.Format("VFileType: {0}", VFileType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestXfer; } }
        public XferIDBlock XferID;

        public RequestXferPacket()
        {
            Header = new LowHeader();
            Header.ID = 156;
            Header.Reliable = true;
            XferID = new XferIDBlock();
        }

        public RequestXferPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            XferID = new XferIDBlock(bytes, ref i);
        }

        public RequestXferPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            XferID = new XferIDBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += XferID.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            XferID.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestXfer ---" + Environment.NewLine;
                output += XferID.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AbortXferPacket : Packet
    {
        /// <exclude/>
        [XmlType("abortxfer_xferid")]
        public class XferIDBlock
        {
            public ulong ID;
            public int Result;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public XferIDBlock() { }
            public XferIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Result = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
                bytes[i++] = (byte)((ID >> 32) % 256);
                bytes[i++] = (byte)((ID >> 40) % 256);
                bytes[i++] = (byte)((ID >> 48) % 256);
                bytes[i++] = (byte)((ID >> 56) % 256);
                bytes[i++] = (byte)(Result % 256);
                bytes[i++] = (byte)((Result >> 8) % 256);
                bytes[i++] = (byte)((Result >> 16) % 256);
                bytes[i++] = (byte)((Result >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- XferID --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.Append(String.Format("Result: {0}", Result));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AbortXfer; } }
        public XferIDBlock XferID;

        public AbortXferPacket()
        {
            Header = new LowHeader();
            Header.ID = 157;
            Header.Reliable = true;
            XferID = new XferIDBlock();
        }

        public AbortXferPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            XferID = new XferIDBlock(bytes, ref i);
        }

        public AbortXferPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            XferID = new XferIDBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += XferID.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            XferID.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AbortXfer ---" + Environment.NewLine;
                output += XferID.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarAppearancePacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarappearance_sender")]
        public class SenderBlock
        {
            public LLUUID ID;
            public bool IsTrial;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public SenderBlock() { }
            public SenderBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    IsTrial = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsTrial) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Sender --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.Append(String.Format("IsTrial: {0}", IsTrial));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarappearance_objectdata")]
        public class ObjectDataBlock
        {
            private byte[] _textureentry;
            public byte[] TextureEntry
            {
                get { return _textureentry; }
                set
                {
                    if (value == null) { _textureentry = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _textureentry = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
                bytes[i++] = (byte)(TextureEntry.Length % 256);
                bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
                Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                Helpers.FieldToString(output, TextureEntry, "TextureEntry");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarappearance_visualparam")]
        public class VisualParamBlock
        {
            public byte ParamValue;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public VisualParamBlock() { }
            public VisualParamBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ParamValue = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = ParamValue;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- VisualParam --");
                output.Append(String.Format("ParamValue: {0}", ParamValue));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarAppearance; } }
        public SenderBlock Sender;
        public ObjectDataBlock ObjectData;
        public VisualParamBlock[] VisualParam;

        public AvatarAppearancePacket()
        {
            Header = new LowHeader();
            Header.ID = 158;
            Header.Reliable = true;
            Sender = new SenderBlock();
            ObjectData = new ObjectDataBlock();
            VisualParam = new VisualParamBlock[0];
        }

        public AvatarAppearancePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Sender = new SenderBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            VisualParam = new VisualParamBlock[count];
            for (int j = 0; j < count; j++)
            { VisualParam[j] = new VisualParamBlock(bytes, ref i); }
        }

        public AvatarAppearancePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Sender = new SenderBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            VisualParam = new VisualParamBlock[count];
            for (int j = 0; j < count; j++)
            { VisualParam[j] = new VisualParamBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Sender.Length;            length += ObjectData.Length;;
            length++;
            for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Sender.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)VisualParam.Length;
            for (int j = 0; j < VisualParam.Length; j++) { VisualParam[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarAppearance ---" + Environment.NewLine;
                output += Sender.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            for (int j = 0; j < VisualParam.Length; j++)
            {
                output += VisualParam[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class SetFollowCamPropertiesPacket : Packet
    {
        /// <exclude/>
        [XmlType("setfollowcamproperties_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("setfollowcamproperties_cameraproperty")]
        public class CameraPropertyBlock
        {
            public int Type;
            public float Value;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public CameraPropertyBlock() { }
            public CameraPropertyBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Value = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(Type % 256);
                bytes[i++] = (byte)((Type >> 8) % 256);
                bytes[i++] = (byte)((Type >> 16) % 256);
                bytes[i++] = (byte)((Type >> 24) % 256);
                ba = BitConverter.GetBytes(Value);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- CameraProperty --");
                output.AppendLine(String.Format("Type: {0}", Type));
                output.Append(String.Format("Value: {0}", Value));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SetFollowCamProperties; } }
        public ObjectDataBlock ObjectData;
        public CameraPropertyBlock[] CameraProperty;

        public SetFollowCamPropertiesPacket()
        {
            Header = new LowHeader();
            Header.ID = 159;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock();
            CameraProperty = new CameraPropertyBlock[0];
        }

        public SetFollowCamPropertiesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ObjectData = new ObjectDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            CameraProperty = new CameraPropertyBlock[count];
            for (int j = 0; j < count; j++)
            { CameraProperty[j] = new CameraPropertyBlock(bytes, ref i); }
        }

        public SetFollowCamPropertiesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ObjectData = new ObjectDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            CameraProperty = new CameraPropertyBlock[count];
            for (int j = 0; j < count; j++)
            { CameraProperty[j] = new CameraPropertyBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ObjectData.Length;;
            length++;
            for (int j = 0; j < CameraProperty.Length; j++) { length += CameraProperty[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)CameraProperty.Length;
            for (int j = 0; j < CameraProperty.Length; j++) { CameraProperty[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SetFollowCamProperties ---" + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            for (int j = 0; j < CameraProperty.Length; j++)
            {
                output += CameraProperty[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ClearFollowCamPropertiesPacket : Packet
    {
        /// <exclude/>
        [XmlType("clearfollowcamproperties_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ClearFollowCamProperties; } }
        public ObjectDataBlock ObjectData;

        public ClearFollowCamPropertiesPacket()
        {
            Header = new LowHeader();
            Header.ID = 160;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock();
        }

        public ClearFollowCamPropertiesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ClearFollowCamPropertiesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ClearFollowCamProperties ---" + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RequestPayPricePacket : Packet
    {
        /// <exclude/>
        [XmlType("requestpayprice_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestPayPrice; } }
        public ObjectDataBlock ObjectData;

        public RequestPayPricePacket()
        {
            Header = new LowHeader();
            Header.ID = 161;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock();
        }

        public RequestPayPricePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public RequestPayPricePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestPayPrice ---" + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PayPriceReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("paypricereply_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;
            public int DefaultPayPrice;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    DefaultPayPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(DefaultPayPrice % 256);
                bytes[i++] = (byte)((DefaultPayPrice >> 8) % 256);
                bytes[i++] = (byte)((DefaultPayPrice >> 16) % 256);
                bytes[i++] = (byte)((DefaultPayPrice >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("DefaultPayPrice: {0}", DefaultPayPrice));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("paypricereply_buttondata")]
        public class ButtonDataBlock
        {
            public int PayButton;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ButtonDataBlock() { }
            public ButtonDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PayButton = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(PayButton % 256);
                bytes[i++] = (byte)((PayButton >> 8) % 256);
                bytes[i++] = (byte)((PayButton >> 16) % 256);
                bytes[i++] = (byte)((PayButton >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ButtonData --");
                output.Append(String.Format("PayButton: {0}", PayButton));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PayPriceReply; } }
        public ObjectDataBlock ObjectData;
        public ButtonDataBlock[] ButtonData;

        public PayPriceReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 162;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock();
            ButtonData = new ButtonDataBlock[0];
        }

        public PayPriceReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ObjectData = new ObjectDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ButtonData = new ButtonDataBlock[count];
            for (int j = 0; j < count; j++)
            { ButtonData[j] = new ButtonDataBlock(bytes, ref i); }
        }

        public PayPriceReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ObjectData = new ObjectDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ButtonData = new ButtonDataBlock[count];
            for (int j = 0; j < count; j++)
            { ButtonData[j] = new ButtonDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ObjectData.Length;;
            length++;
            for (int j = 0; j < ButtonData.Length; j++) { length += ButtonData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ButtonData.Length;
            for (int j = 0; j < ButtonData.Length; j++) { ButtonData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PayPriceReply ---" + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            for (int j = 0; j < ButtonData.Length; j++)
            {
                output += ButtonData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class KickUserPacket : Packet
    {
        /// <exclude/>
        [XmlType("kickuser_targetblock")]
        public class TargetBlockBlock
        {
            public uint TargetIP;
            public ushort TargetPort;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 6;
                }
            }

            public TargetBlockBlock() { }
            public TargetBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TargetPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(TargetIP % 256);
                bytes[i++] = (byte)((TargetIP >> 8) % 256);
                bytes[i++] = (byte)((TargetIP >> 16) % 256);
                bytes[i++] = (byte)((TargetIP >> 24) % 256);
                bytes[i++] = (byte)((TargetPort >> 8) % 256);
                bytes[i++] = (byte)(TargetPort % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TargetBlock --");
                output.AppendLine(String.Format("TargetIP: {0}", TargetIP));
                output.Append(String.Format("TargetPort: {0}", TargetPort));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("kickuser_userinfo")]
        public class UserInfoBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            private byte[] _reason;
            public byte[] Reason
            {
                get { return _reason; }
                set
                {
                    if (value == null) { _reason = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _reason = new byte[value.Length]; Buffer.BlockCopy(value, 0, _reason, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 32;
                    if (Reason != null) { length += 2 + Reason.Length; }
                    return length;
                }
            }

            public UserInfoBlock() { }
            public UserInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _reason = new byte[length];
                    Buffer.BlockCopy(bytes, i, _reason, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Reason == null) { Console.WriteLine("Warning: Reason is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Reason.Length % 256);
                bytes[i++] = (byte)((Reason.Length >> 8) % 256);
                Buffer.BlockCopy(Reason, 0, bytes, i, Reason.Length); i += Reason.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UserInfo --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                Helpers.FieldToString(output, Reason, "Reason");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.KickUser; } }
        public TargetBlockBlock TargetBlock;
        public UserInfoBlock UserInfo;

        public KickUserPacket()
        {
            Header = new LowHeader();
            Header.ID = 163;
            Header.Reliable = true;
            TargetBlock = new TargetBlockBlock();
            UserInfo = new UserInfoBlock();
        }

        public KickUserPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TargetBlock = new TargetBlockBlock(bytes, ref i);
            UserInfo = new UserInfoBlock(bytes, ref i);
        }

        public KickUserPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TargetBlock = new TargetBlockBlock(bytes, ref i);
            UserInfo = new UserInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TargetBlock.Length;            length += UserInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TargetBlock.ToBytes(bytes, ref i);
            UserInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- KickUser ---" + Environment.NewLine;
                output += TargetBlock.ToString() + Environment.NewLine;
                output += UserInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class KickUserAckPacket : Packet
    {
        /// <exclude/>
        [XmlType("kickuserack_userinfo")]
        public class UserInfoBlock
        {
            public LLUUID SessionID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public UserInfoBlock() { }
            public UserInfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UserInfo --");
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.KickUserAck; } }
        public UserInfoBlock UserInfo;

        public KickUserAckPacket()
        {
            Header = new LowHeader();
            Header.ID = 164;
            Header.Reliable = true;
            UserInfo = new UserInfoBlock();
        }

        public KickUserAckPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            UserInfo = new UserInfoBlock(bytes, ref i);
        }

        public KickUserAckPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            UserInfo = new UserInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += UserInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            UserInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- KickUserAck ---" + Environment.NewLine;
                output += UserInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GodKickUserPacket : Packet
    {
        /// <exclude/>
        [XmlType("godkickuser_userinfo")]
        public class UserInfoBlock
        {
            public LLUUID GodID;
            public LLUUID GodSessionID;
            public LLUUID AgentID;
            public uint KickFlags;
            private byte[] _reason;
            public byte[] Reason
            {
                get { return _reason; }
                set
                {
                    if (value == null) { _reason = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _reason = new byte[value.Length]; Buffer.BlockCopy(value, 0, _reason, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 52;
                    if (Reason != null) { length += 2 + Reason.Length; }
                    return length;
                }
            }

            public UserInfoBlock() { }
            public UserInfoBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GodID = new LLUUID(bytes, i); i += 16;
                    GodSessionID = new LLUUID(bytes, i); i += 16;
                    AgentID = new LLUUID(bytes, i); i += 16;
                    KickFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _reason = new byte[length];
                    Buffer.BlockCopy(bytes, i, _reason, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GodID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GodSessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(KickFlags % 256);
                bytes[i++] = (byte)((KickFlags >> 8) % 256);
                bytes[i++] = (byte)((KickFlags >> 16) % 256);
                bytes[i++] = (byte)((KickFlags >> 24) % 256);
                if(Reason == null) { Console.WriteLine("Warning: Reason is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Reason.Length % 256);
                bytes[i++] = (byte)((Reason.Length >> 8) % 256);
                Buffer.BlockCopy(Reason, 0, bytes, i, Reason.Length); i += Reason.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UserInfo --");
                output.AppendLine(String.Format("GodID: {0}", GodID));
                output.AppendLine(String.Format("GodSessionID: {0}", GodSessionID));
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("KickFlags: {0}", KickFlags));
                Helpers.FieldToString(output, Reason, "Reason");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GodKickUser; } }
        public UserInfoBlock UserInfo;

        public GodKickUserPacket()
        {
            Header = new LowHeader();
            Header.ID = 165;
            Header.Reliable = true;
            UserInfo = new UserInfoBlock();
        }

        public GodKickUserPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            UserInfo = new UserInfoBlock(bytes, ref i);
        }

        public GodKickUserPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            UserInfo = new UserInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += UserInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            UserInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GodKickUser ---" + Environment.NewLine;
                output += UserInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EjectUserPacket : Packet
    {
        /// <exclude/>
        [XmlType("ejectuser_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("ejectuser_data")]
        public class DataBlock
        {
            public LLUUID TargetID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TargetID: {0}", TargetID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EjectUser; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public EjectUserPacket()
        {
            Header = new LowHeader();
            Header.ID = 167;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public EjectUserPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public EjectUserPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EjectUser ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class FreezeUserPacket : Packet
    {
        /// <exclude/>
        [XmlType("freezeuser_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("freezeuser_data")]
        public class DataBlock
        {
            public LLUUID TargetID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TargetID: {0}", TargetID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.FreezeUser; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public FreezeUserPacket()
        {
            Header = new LowHeader();
            Header.ID = 168;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public FreezeUserPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public FreezeUserPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- FreezeUser ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarPropertiesRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarpropertiesrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID AvatarID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    AvatarID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("AvatarID: {0}", AvatarID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarPropertiesRequest; } }
        public AgentDataBlock AgentData;

        public AvatarPropertiesRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 169;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AvatarPropertiesRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AvatarPropertiesRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarPropertiesRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarPropertiesReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarpropertiesreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID AvatarID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    AvatarID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("AvatarID: {0}", AvatarID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarpropertiesreply_propertiesdata")]
        public class PropertiesDataBlock
        {
            public LLUUID ImageID;
            public LLUUID FLImageID;
            public LLUUID PartnerID;
            private byte[] _abouttext;
            public byte[] AboutText
            {
                get { return _abouttext; }
                set
                {
                    if (value == null) { _abouttext = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _abouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _abouttext, 0, value.Length); }
                }
            }
            private byte[] _flabouttext;
            public byte[] FLAboutText
            {
                get { return _flabouttext; }
                set
                {
                    if (value == null) { _flabouttext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _flabouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _flabouttext, 0, value.Length); }
                }
            }
            private byte[] _bornon;
            public byte[] BornOn
            {
                get { return _bornon; }
                set
                {
                    if (value == null) { _bornon = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _bornon = new byte[value.Length]; Buffer.BlockCopy(value, 0, _bornon, 0, value.Length); }
                }
            }
            private byte[] _profileurl;
            public byte[] ProfileURL
            {
                get { return _profileurl; }
                set
                {
                    if (value == null) { _profileurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _profileurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _profileurl, 0, value.Length); }
                }
            }
            private byte[] _chartermember;
            public byte[] CharterMember
            {
                get { return _chartermember; }
                set
                {
                    if (value == null) { _chartermember = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _chartermember = new byte[value.Length]; Buffer.BlockCopy(value, 0, _chartermember, 0, value.Length); }
                }
            }
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 52;
                    if (AboutText != null) { length += 2 + AboutText.Length; }
                    if (FLAboutText != null) { length += 1 + FLAboutText.Length; }
                    if (BornOn != null) { length += 1 + BornOn.Length; }
                    if (ProfileURL != null) { length += 1 + ProfileURL.Length; }
                    if (CharterMember != null) { length += 1 + CharterMember.Length; }
                    return length;
                }
            }

            public PropertiesDataBlock() { }
            public PropertiesDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ImageID = new LLUUID(bytes, i); i += 16;
                    FLImageID = new LLUUID(bytes, i); i += 16;
                    PartnerID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _abouttext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _abouttext, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _flabouttext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _flabouttext, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _bornon = new byte[length];
                    Buffer.BlockCopy(bytes, i, _bornon, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _profileurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _profileurl, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _chartermember = new byte[length];
                    Buffer.BlockCopy(bytes, i, _chartermember, 0, length); i += length;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FLImageID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(PartnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(AboutText == null) { Console.WriteLine("Warning: AboutText is null, in " + this.GetType()); }
                bytes[i++] = (byte)(AboutText.Length % 256);
                bytes[i++] = (byte)((AboutText.Length >> 8) % 256);
                Buffer.BlockCopy(AboutText, 0, bytes, i, AboutText.Length); i += AboutText.Length;
                if(FLAboutText == null) { Console.WriteLine("Warning: FLAboutText is null, in " + this.GetType()); }
                bytes[i++] = (byte)FLAboutText.Length;
                Buffer.BlockCopy(FLAboutText, 0, bytes, i, FLAboutText.Length); i += FLAboutText.Length;
                if(BornOn == null) { Console.WriteLine("Warning: BornOn is null, in " + this.GetType()); }
                bytes[i++] = (byte)BornOn.Length;
                Buffer.BlockCopy(BornOn, 0, bytes, i, BornOn.Length); i += BornOn.Length;
                if(ProfileURL == null) { Console.WriteLine("Warning: ProfileURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)ProfileURL.Length;
                Buffer.BlockCopy(ProfileURL, 0, bytes, i, ProfileURL.Length); i += ProfileURL.Length;
                if(CharterMember == null) { Console.WriteLine("Warning: CharterMember is null, in " + this.GetType()); }
                bytes[i++] = (byte)CharterMember.Length;
                Buffer.BlockCopy(CharterMember, 0, bytes, i, CharterMember.Length); i += CharterMember.Length;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PropertiesData --");
                output.AppendLine(String.Format("ImageID: {0}", ImageID));
                output.AppendLine(String.Format("FLImageID: {0}", FLImageID));
                output.AppendLine(String.Format("PartnerID: {0}", PartnerID));
                Helpers.FieldToString(output, AboutText, "AboutText");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, FLAboutText, "FLAboutText");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, BornOn, "BornOn");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, ProfileURL, "ProfileURL");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, CharterMember, "CharterMember");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarPropertiesReply; } }
        public AgentDataBlock AgentData;
        public PropertiesDataBlock PropertiesData;

        public AvatarPropertiesReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 171;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            PropertiesData = new PropertiesDataBlock();
        }

        public AvatarPropertiesReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public AvatarPropertiesReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += PropertiesData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            PropertiesData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarPropertiesReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += PropertiesData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarInterestsReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarinterestsreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID AvatarID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    AvatarID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("AvatarID: {0}", AvatarID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarinterestsreply_propertiesdata")]
        public class PropertiesDataBlock
        {
            public uint WantToMask;
            private byte[] _wanttotext;
            public byte[] WantToText
            {
                get { return _wanttotext; }
                set
                {
                    if (value == null) { _wanttotext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _wanttotext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _wanttotext, 0, value.Length); }
                }
            }
            public uint SkillsMask;
            private byte[] _skillstext;
            public byte[] SkillsText
            {
                get { return _skillstext; }
                set
                {
                    if (value == null) { _skillstext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _skillstext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _skillstext, 0, value.Length); }
                }
            }
            private byte[] _languagestext;
            public byte[] LanguagesText
            {
                get { return _languagestext; }
                set
                {
                    if (value == null) { _languagestext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _languagestext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _languagestext, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 8;
                    if (WantToText != null) { length += 1 + WantToText.Length; }
                    if (SkillsText != null) { length += 1 + SkillsText.Length; }
                    if (LanguagesText != null) { length += 1 + LanguagesText.Length; }
                    return length;
                }
            }

            public PropertiesDataBlock() { }
            public PropertiesDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    WantToMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _wanttotext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _wanttotext, 0, length); i += length;
                    SkillsMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _skillstext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _skillstext, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _languagestext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _languagestext, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(WantToMask % 256);
                bytes[i++] = (byte)((WantToMask >> 8) % 256);
                bytes[i++] = (byte)((WantToMask >> 16) % 256);
                bytes[i++] = (byte)((WantToMask >> 24) % 256);
                if(WantToText == null) { Console.WriteLine("Warning: WantToText is null, in " + this.GetType()); }
                bytes[i++] = (byte)WantToText.Length;
                Buffer.BlockCopy(WantToText, 0, bytes, i, WantToText.Length); i += WantToText.Length;
                bytes[i++] = (byte)(SkillsMask % 256);
                bytes[i++] = (byte)((SkillsMask >> 8) % 256);
                bytes[i++] = (byte)((SkillsMask >> 16) % 256);
                bytes[i++] = (byte)((SkillsMask >> 24) % 256);
                if(SkillsText == null) { Console.WriteLine("Warning: SkillsText is null, in " + this.GetType()); }
                bytes[i++] = (byte)SkillsText.Length;
                Buffer.BlockCopy(SkillsText, 0, bytes, i, SkillsText.Length); i += SkillsText.Length;
                if(LanguagesText == null) { Console.WriteLine("Warning: LanguagesText is null, in " + this.GetType()); }
                bytes[i++] = (byte)LanguagesText.Length;
                Buffer.BlockCopy(LanguagesText, 0, bytes, i, LanguagesText.Length); i += LanguagesText.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PropertiesData --");
                output.AppendLine(String.Format("WantToMask: {0}", WantToMask));
                Helpers.FieldToString(output, WantToText, "WantToText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SkillsMask: {0}", SkillsMask));
                Helpers.FieldToString(output, SkillsText, "SkillsText");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LanguagesText, "LanguagesText");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarInterestsReply; } }
        public AgentDataBlock AgentData;
        public PropertiesDataBlock PropertiesData;

        public AvatarInterestsReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 172;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            PropertiesData = new PropertiesDataBlock();
        }

        public AvatarInterestsReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public AvatarInterestsReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += PropertiesData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            PropertiesData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarInterestsReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += PropertiesData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarGroupsReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatargroupsreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID AvatarID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    AvatarID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("AvatarID: {0}", AvatarID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatargroupsreply_groupdata")]
        public class GroupDataBlock
        {
            public ulong GroupPowers;
            public bool AcceptNotices;
            private byte[] _grouptitle;
            public byte[] GroupTitle
            {
                get { return _grouptitle; }
                set
                {
                    if (value == null) { _grouptitle = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _grouptitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _grouptitle, 0, value.Length); }
                }
            }
            public LLUUID GroupID;
            private byte[] _groupname;
            public byte[] GroupName
            {
                get { return _groupname; }
                set
                {
                    if (value == null) { _groupname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
                }
            }
            public LLUUID GroupInsigniaID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 41;
                    if (GroupTitle != null) { length += 1 + GroupTitle.Length; }
                    if (GroupName != null) { length += 1 + GroupName.Length; }
                    return length;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _grouptitle = new byte[length];
                    Buffer.BlockCopy(bytes, i, _grouptitle, 0, length); i += length;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _groupname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
                    GroupInsigniaID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(GroupPowers % 256);
                bytes[i++] = (byte)((GroupPowers >> 8) % 256);
                bytes[i++] = (byte)((GroupPowers >> 16) % 256);
                bytes[i++] = (byte)((GroupPowers >> 24) % 256);
                bytes[i++] = (byte)((GroupPowers >> 32) % 256);
                bytes[i++] = (byte)((GroupPowers >> 40) % 256);
                bytes[i++] = (byte)((GroupPowers >> 48) % 256);
                bytes[i++] = (byte)((GroupPowers >> 56) % 256);
                bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
                if(GroupTitle == null) { Console.WriteLine("Warning: GroupTitle is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupTitle.Length;
                Buffer.BlockCopy(GroupTitle, 0, bytes, i, GroupTitle.Length); i += GroupTitle.Length;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupName.Length;
                Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
                Buffer.BlockCopy(GroupInsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
                output.AppendLine(String.Format("AcceptNotices: {0}", AcceptNotices));
                Helpers.FieldToString(output, GroupTitle, "GroupTitle");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                Helpers.FieldToString(output, GroupName, "GroupName");
                output.Append(Environment.NewLine);
                output.Append(String.Format("GroupInsigniaID: {0}", GroupInsigniaID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarGroupsReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock[] GroupData;

        public AvatarGroupsReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 173;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock[0];
        }

        public AvatarGroupsReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
        }

        public AvatarGroupsReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)GroupData.Length;
            for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarGroupsReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < GroupData.Length; j++)
            {
                output += GroupData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AvatarPropertiesUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarpropertiesupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarpropertiesupdate_propertiesdata")]
        public class PropertiesDataBlock
        {
            public LLUUID ImageID;
            public LLUUID FLImageID;
            private byte[] _abouttext;
            public byte[] AboutText
            {
                get { return _abouttext; }
                set
                {
                    if (value == null) { _abouttext = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _abouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _abouttext, 0, value.Length); }
                }
            }
            private byte[] _flabouttext;
            public byte[] FLAboutText
            {
                get { return _flabouttext; }
                set
                {
                    if (value == null) { _flabouttext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _flabouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _flabouttext, 0, value.Length); }
                }
            }
            public bool AllowPublish;
            public bool MaturePublish;
            private byte[] _profileurl;
            public byte[] ProfileURL
            {
                get { return _profileurl; }
                set
                {
                    if (value == null) { _profileurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _profileurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _profileurl, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 34;
                    if (AboutText != null) { length += 2 + AboutText.Length; }
                    if (FLAboutText != null) { length += 1 + FLAboutText.Length; }
                    if (ProfileURL != null) { length += 1 + ProfileURL.Length; }
                    return length;
                }
            }

            public PropertiesDataBlock() { }
            public PropertiesDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ImageID = new LLUUID(bytes, i); i += 16;
                    FLImageID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _abouttext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _abouttext, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _flabouttext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _flabouttext, 0, length); i += length;
                    AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _profileurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _profileurl, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FLImageID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(AboutText == null) { Console.WriteLine("Warning: AboutText is null, in " + this.GetType()); }
                bytes[i++] = (byte)(AboutText.Length % 256);
                bytes[i++] = (byte)((AboutText.Length >> 8) % 256);
                Buffer.BlockCopy(AboutText, 0, bytes, i, AboutText.Length); i += AboutText.Length;
                if(FLAboutText == null) { Console.WriteLine("Warning: FLAboutText is null, in " + this.GetType()); }
                bytes[i++] = (byte)FLAboutText.Length;
                Buffer.BlockCopy(FLAboutText, 0, bytes, i, FLAboutText.Length); i += FLAboutText.Length;
                bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
                bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
                if(ProfileURL == null) { Console.WriteLine("Warning: ProfileURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)ProfileURL.Length;
                Buffer.BlockCopy(ProfileURL, 0, bytes, i, ProfileURL.Length); i += ProfileURL.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PropertiesData --");
                output.AppendLine(String.Format("ImageID: {0}", ImageID));
                output.AppendLine(String.Format("FLImageID: {0}", FLImageID));
                Helpers.FieldToString(output, AboutText, "AboutText");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, FLAboutText, "FLAboutText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
                output.AppendLine(String.Format("MaturePublish: {0}", MaturePublish));
                Helpers.FieldToString(output, ProfileURL, "ProfileURL");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarPropertiesUpdate; } }
        public AgentDataBlock AgentData;
        public PropertiesDataBlock PropertiesData;

        public AvatarPropertiesUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 174;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            PropertiesData = new PropertiesDataBlock();
        }

        public AvatarPropertiesUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public AvatarPropertiesUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += PropertiesData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            PropertiesData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarPropertiesUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += PropertiesData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarInterestsUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarinterestsupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarinterestsupdate_propertiesdata")]
        public class PropertiesDataBlock
        {
            public uint WantToMask;
            private byte[] _wanttotext;
            public byte[] WantToText
            {
                get { return _wanttotext; }
                set
                {
                    if (value == null) { _wanttotext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _wanttotext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _wanttotext, 0, value.Length); }
                }
            }
            public uint SkillsMask;
            private byte[] _skillstext;
            public byte[] SkillsText
            {
                get { return _skillstext; }
                set
                {
                    if (value == null) { _skillstext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _skillstext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _skillstext, 0, value.Length); }
                }
            }
            private byte[] _languagestext;
            public byte[] LanguagesText
            {
                get { return _languagestext; }
                set
                {
                    if (value == null) { _languagestext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _languagestext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _languagestext, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 8;
                    if (WantToText != null) { length += 1 + WantToText.Length; }
                    if (SkillsText != null) { length += 1 + SkillsText.Length; }
                    if (LanguagesText != null) { length += 1 + LanguagesText.Length; }
                    return length;
                }
            }

            public PropertiesDataBlock() { }
            public PropertiesDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    WantToMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _wanttotext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _wanttotext, 0, length); i += length;
                    SkillsMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _skillstext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _skillstext, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _languagestext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _languagestext, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(WantToMask % 256);
                bytes[i++] = (byte)((WantToMask >> 8) % 256);
                bytes[i++] = (byte)((WantToMask >> 16) % 256);
                bytes[i++] = (byte)((WantToMask >> 24) % 256);
                if(WantToText == null) { Console.WriteLine("Warning: WantToText is null, in " + this.GetType()); }
                bytes[i++] = (byte)WantToText.Length;
                Buffer.BlockCopy(WantToText, 0, bytes, i, WantToText.Length); i += WantToText.Length;
                bytes[i++] = (byte)(SkillsMask % 256);
                bytes[i++] = (byte)((SkillsMask >> 8) % 256);
                bytes[i++] = (byte)((SkillsMask >> 16) % 256);
                bytes[i++] = (byte)((SkillsMask >> 24) % 256);
                if(SkillsText == null) { Console.WriteLine("Warning: SkillsText is null, in " + this.GetType()); }
                bytes[i++] = (byte)SkillsText.Length;
                Buffer.BlockCopy(SkillsText, 0, bytes, i, SkillsText.Length); i += SkillsText.Length;
                if(LanguagesText == null) { Console.WriteLine("Warning: LanguagesText is null, in " + this.GetType()); }
                bytes[i++] = (byte)LanguagesText.Length;
                Buffer.BlockCopy(LanguagesText, 0, bytes, i, LanguagesText.Length); i += LanguagesText.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PropertiesData --");
                output.AppendLine(String.Format("WantToMask: {0}", WantToMask));
                Helpers.FieldToString(output, WantToText, "WantToText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SkillsMask: {0}", SkillsMask));
                Helpers.FieldToString(output, SkillsText, "SkillsText");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LanguagesText, "LanguagesText");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarInterestsUpdate; } }
        public AgentDataBlock AgentData;
        public PropertiesDataBlock PropertiesData;

        public AvatarInterestsUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 175;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            PropertiesData = new PropertiesDataBlock();
        }

        public AvatarInterestsUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public AvatarInterestsUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            PropertiesData = new PropertiesDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += PropertiesData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            PropertiesData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarInterestsUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += PropertiesData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarNotesReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarnotesreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarnotesreply_data")]
        public class DataBlock
        {
            public LLUUID TargetID;
            private byte[] _notes;
            public byte[] Notes
            {
                get { return _notes; }
                set
                {
                    if (value == null) { _notes = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _notes = new byte[value.Length]; Buffer.BlockCopy(value, 0, _notes, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Notes != null) { length += 2 + Notes.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _notes = new byte[length];
                    Buffer.BlockCopy(bytes, i, _notes, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Notes == null) { Console.WriteLine("Warning: Notes is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Notes.Length % 256);
                bytes[i++] = (byte)((Notes.Length >> 8) % 256);
                Buffer.BlockCopy(Notes, 0, bytes, i, Notes.Length); i += Notes.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TargetID: {0}", TargetID));
                Helpers.FieldToString(output, Notes, "Notes");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarNotesReply; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public AvatarNotesReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 176;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public AvatarNotesReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public AvatarNotesReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarNotesReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarNotesUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarnotesupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarnotesupdate_data")]
        public class DataBlock
        {
            public LLUUID TargetID;
            private byte[] _notes;
            public byte[] Notes
            {
                get { return _notes; }
                set
                {
                    if (value == null) { _notes = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _notes = new byte[value.Length]; Buffer.BlockCopy(value, 0, _notes, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Notes != null) { length += 2 + Notes.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _notes = new byte[length];
                    Buffer.BlockCopy(bytes, i, _notes, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Notes == null) { Console.WriteLine("Warning: Notes is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Notes.Length % 256);
                bytes[i++] = (byte)((Notes.Length >> 8) % 256);
                Buffer.BlockCopy(Notes, 0, bytes, i, Notes.Length); i += Notes.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TargetID: {0}", TargetID));
                Helpers.FieldToString(output, Notes, "Notes");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarNotesUpdate; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public AvatarNotesUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 177;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public AvatarNotesUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public AvatarNotesUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarNotesUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarPicksReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarpicksreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID TargetID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    TargetID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("TargetID: {0}", TargetID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarpicksreply_data")]
        public class DataBlock
        {
            public LLUUID PickID;
            private byte[] _pickname;
            public byte[] PickName
            {
                get { return _pickname; }
                set
                {
                    if (value == null) { _pickname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _pickname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _pickname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (PickName != null) { length += 1 + PickName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    PickID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _pickname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _pickname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(PickName == null) { Console.WriteLine("Warning: PickName is null, in " + this.GetType()); }
                bytes[i++] = (byte)PickName.Length;
                Buffer.BlockCopy(PickName, 0, bytes, i, PickName.Length); i += PickName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("PickID: {0}", PickID));
                Helpers.FieldToString(output, PickName, "PickName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarPicksReply; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public AvatarPicksReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 178;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public AvatarPicksReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public AvatarPicksReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarPicksReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class EventInfoRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("eventinforequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("eventinforequest_eventdata")]
        public class EventDataBlock
        {
            public uint EventID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public EventDataBlock() { }
            public EventDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EventData --");
                output.Append(String.Format("EventID: {0}", EventID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EventInfoRequest; } }
        public AgentDataBlock AgentData;
        public EventDataBlock EventData;

        public EventInfoRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 179;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            EventData = new EventDataBlock();
        }

        public EventInfoRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public EventInfoRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += EventData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            EventData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EventInfoRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += EventData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EventInfoReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("eventinforeply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("eventinforeply_eventdata")]
        public class EventDataBlock
        {
            public uint EventID;
            private byte[] _creator;
            public byte[] Creator
            {
                get { return _creator; }
                set
                {
                    if (value == null) { _creator = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _creator = new byte[value.Length]; Buffer.BlockCopy(value, 0, _creator, 0, value.Length); }
                }
            }
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _category;
            public byte[] Category
            {
                get { return _category; }
                set
                {
                    if (value == null) { _category = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _category = new byte[value.Length]; Buffer.BlockCopy(value, 0, _category, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            private byte[] _date;
            public byte[] Date
            {
                get { return _date; }
                set
                {
                    if (value == null) { _date = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _date = new byte[value.Length]; Buffer.BlockCopy(value, 0, _date, 0, value.Length); }
                }
            }
            public uint DateUTC;
            public uint Duration;
            public uint Cover;
            public uint Amount;
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLVector3d GlobalPos;
            public uint EventFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 48;
                    if (Creator != null) { length += 1 + Creator.Length; }
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Category != null) { length += 1 + Category.Length; }
                    if (Desc != null) { length += 2 + Desc.Length; }
                    if (Date != null) { length += 1 + Date.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public EventDataBlock() { }
            public EventDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _creator = new byte[length];
                    Buffer.BlockCopy(bytes, i, _creator, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _category = new byte[length];
                    Buffer.BlockCopy(bytes, i, _category, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _date = new byte[length];
                    Buffer.BlockCopy(bytes, i, _date, 0, length); i += length;
                    DateUTC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Duration = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Cover = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Amount = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    GlobalPos = new LLVector3d(bytes, i); i += 24;
                    EventFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
                if(Creator == null) { Console.WriteLine("Warning: Creator is null, in " + this.GetType()); }
                bytes[i++] = (byte)Creator.Length;
                Buffer.BlockCopy(Creator, 0, bytes, i, Creator.Length); i += Creator.Length;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Category == null) { Console.WriteLine("Warning: Category is null, in " + this.GetType()); }
                bytes[i++] = (byte)Category.Length;
                Buffer.BlockCopy(Category, 0, bytes, i, Category.Length); i += Category.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Desc.Length % 256);
                bytes[i++] = (byte)((Desc.Length >> 8) % 256);
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                if(Date == null) { Console.WriteLine("Warning: Date is null, in " + this.GetType()); }
                bytes[i++] = (byte)Date.Length;
                Buffer.BlockCopy(Date, 0, bytes, i, Date.Length); i += Date.Length;
                bytes[i++] = (byte)(DateUTC % 256);
                bytes[i++] = (byte)((DateUTC >> 8) % 256);
                bytes[i++] = (byte)((DateUTC >> 16) % 256);
                bytes[i++] = (byte)((DateUTC >> 24) % 256);
                bytes[i++] = (byte)(Duration % 256);
                bytes[i++] = (byte)((Duration >> 8) % 256);
                bytes[i++] = (byte)((Duration >> 16) % 256);
                bytes[i++] = (byte)((Duration >> 24) % 256);
                bytes[i++] = (byte)(Cover % 256);
                bytes[i++] = (byte)((Cover >> 8) % 256);
                bytes[i++] = (byte)((Cover >> 16) % 256);
                bytes[i++] = (byte)((Cover >> 24) % 256);
                bytes[i++] = (byte)(Amount % 256);
                bytes[i++] = (byte)((Amount >> 8) % 256);
                bytes[i++] = (byte)((Amount >> 16) % 256);
                bytes[i++] = (byte)((Amount >> 24) % 256);
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(GlobalPos.GetBytes(), 0, bytes, i, 24); i += 24;
                bytes[i++] = (byte)(EventFlags % 256);
                bytes[i++] = (byte)((EventFlags >> 8) % 256);
                bytes[i++] = (byte)((EventFlags >> 16) % 256);
                bytes[i++] = (byte)((EventFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EventData --");
                output.AppendLine(String.Format("EventID: {0}", EventID));
                Helpers.FieldToString(output, Creator, "Creator");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Category, "Category");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Date, "Date");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("DateUTC: {0}", DateUTC));
                output.AppendLine(String.Format("Duration: {0}", Duration));
                output.AppendLine(String.Format("Cover: {0}", Cover));
                output.AppendLine(String.Format("Amount: {0}", Amount));
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("GlobalPos: {0}", GlobalPos));
                output.Append(String.Format("EventFlags: {0}", EventFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EventInfoReply; } }
        public AgentDataBlock AgentData;
        public EventDataBlock EventData;

        public EventInfoReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 180;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            EventData = new EventDataBlock();
        }

        public EventInfoReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public EventInfoReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += EventData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            EventData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EventInfoReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += EventData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EventNotificationAddRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("eventnotificationaddrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("eventnotificationaddrequest_eventdata")]
        public class EventDataBlock
        {
            public uint EventID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public EventDataBlock() { }
            public EventDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EventData --");
                output.Append(String.Format("EventID: {0}", EventID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EventNotificationAddRequest; } }
        public AgentDataBlock AgentData;
        public EventDataBlock EventData;

        public EventNotificationAddRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 181;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            EventData = new EventDataBlock();
        }

        public EventNotificationAddRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public EventNotificationAddRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += EventData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            EventData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EventNotificationAddRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += EventData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EventNotificationRemoveRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("eventnotificationremoverequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("eventnotificationremoverequest_eventdata")]
        public class EventDataBlock
        {
            public uint EventID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public EventDataBlock() { }
            public EventDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EventData --");
                output.Append(String.Format("EventID: {0}", EventID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EventNotificationRemoveRequest; } }
        public AgentDataBlock AgentData;
        public EventDataBlock EventData;

        public EventNotificationRemoveRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 182;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            EventData = new EventDataBlock();
        }

        public EventNotificationRemoveRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public EventNotificationRemoveRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += EventData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            EventData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EventNotificationRemoveRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += EventData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EventGodDeletePacket : Packet
    {
        /// <exclude/>
        [XmlType("eventgoddelete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("eventgoddelete_eventdata")]
        public class EventDataBlock
        {
            public uint EventID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public EventDataBlock() { }
            public EventDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EventData --");
                output.Append(String.Format("EventID: {0}", EventID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("eventgoddelete_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            private byte[] _querytext;
            public byte[] QueryText
            {
                get { return _querytext; }
                set
                {
                    if (value == null) { _querytext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
                }
            }
            public uint QueryFlags;
            public int QueryStart;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (QueryText != null) { length += 1 + QueryText.Length; }
                    return length;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _querytext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
                    QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
                bytes[i++] = (byte)QueryText.Length;
                Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
                bytes[i++] = (byte)(QueryFlags % 256);
                bytes[i++] = (byte)((QueryFlags >> 8) % 256);
                bytes[i++] = (byte)((QueryFlags >> 16) % 256);
                bytes[i++] = (byte)((QueryFlags >> 24) % 256);
                bytes[i++] = (byte)(QueryStart % 256);
                bytes[i++] = (byte)((QueryStart >> 8) % 256);
                bytes[i++] = (byte)((QueryStart >> 16) % 256);
                bytes[i++] = (byte)((QueryStart >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                Helpers.FieldToString(output, QueryText, "QueryText");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
                output.Append(String.Format("QueryStart: {0}", QueryStart));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EventGodDelete; } }
        public AgentDataBlock AgentData;
        public EventDataBlock EventData;
        public QueryDataBlock QueryData;

        public EventGodDeletePacket()
        {
            Header = new LowHeader();
            Header.ID = 183;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            EventData = new EventDataBlock();
            QueryData = new QueryDataBlock();
        }

        public EventGodDeletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public EventGodDeletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += EventData.Length;            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            EventData.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EventGodDelete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += EventData.ToString() + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PickInfoReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("pickinforeply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("pickinforeply_data")]
        public class DataBlock
        {
            public LLUUID PickID;
            public LLUUID CreatorID;
            public bool TopPick;
            public LLUUID ParcelID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            public LLUUID SnapshotID;
            private byte[] _user;
            public byte[] User
            {
                get { return _user; }
                set
                {
                    if (value == null) { _user = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _user = new byte[value.Length]; Buffer.BlockCopy(value, 0, _user, 0, value.Length); }
                }
            }
            private byte[] _originalname;
            public byte[] OriginalName
            {
                get { return _originalname; }
                set
                {
                    if (value == null) { _originalname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _originalname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _originalname, 0, value.Length); }
                }
            }
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLVector3d PosGlobal;
            public int SortOrder;
            public bool Enabled;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 94;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 2 + Desc.Length; }
                    if (User != null) { length += 1 + User.Length; }
                    if (OriginalName != null) { length += 1 + OriginalName.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    PickID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    TopPick = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _user = new byte[length];
                    Buffer.BlockCopy(bytes, i, _user, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _originalname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _originalname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    PosGlobal = new LLVector3d(bytes, i); i += 24;
                    SortOrder = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Enabled = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((TopPick) ? 1 : 0);
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Desc.Length % 256);
                bytes[i++] = (byte)((Desc.Length >> 8) % 256);
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(User == null) { Console.WriteLine("Warning: User is null, in " + this.GetType()); }
                bytes[i++] = (byte)User.Length;
                Buffer.BlockCopy(User, 0, bytes, i, User.Length); i += User.Length;
                if(OriginalName == null) { Console.WriteLine("Warning: OriginalName is null, in " + this.GetType()); }
                bytes[i++] = (byte)OriginalName.Length;
                Buffer.BlockCopy(OriginalName, 0, bytes, i, OriginalName.Length); i += OriginalName.Length;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
                bytes[i++] = (byte)(SortOrder % 256);
                bytes[i++] = (byte)((SortOrder >> 8) % 256);
                bytes[i++] = (byte)((SortOrder >> 16) % 256);
                bytes[i++] = (byte)((SortOrder >> 24) % 256);
                bytes[i++] = (byte)((Enabled) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("PickID: {0}", PickID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("TopPick: {0}", TopPick));
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                Helpers.FieldToString(output, User, "User");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, OriginalName, "OriginalName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
                output.AppendLine(String.Format("SortOrder: {0}", SortOrder));
                output.Append(String.Format("Enabled: {0}", Enabled));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PickInfoReply; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public PickInfoReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 184;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public PickInfoReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public PickInfoReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PickInfoReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PickInfoUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("pickinfoupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("pickinfoupdate_data")]
        public class DataBlock
        {
            public LLUUID PickID;
            public LLUUID CreatorID;
            public bool TopPick;
            public LLUUID ParcelID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            public LLUUID SnapshotID;
            public LLVector3d PosGlobal;
            public int SortOrder;
            public bool Enabled;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 94;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 2 + Desc.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    PickID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    TopPick = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    PosGlobal = new LLVector3d(bytes, i); i += 24;
                    SortOrder = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Enabled = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((TopPick) ? 1 : 0);
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Desc.Length % 256);
                bytes[i++] = (byte)((Desc.Length >> 8) % 256);
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
                bytes[i++] = (byte)(SortOrder % 256);
                bytes[i++] = (byte)((SortOrder >> 8) % 256);
                bytes[i++] = (byte)((SortOrder >> 16) % 256);
                bytes[i++] = (byte)((SortOrder >> 24) % 256);
                bytes[i++] = (byte)((Enabled) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("PickID: {0}", PickID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("TopPick: {0}", TopPick));
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
                output.AppendLine(String.Format("SortOrder: {0}", SortOrder));
                output.Append(String.Format("Enabled: {0}", Enabled));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PickInfoUpdate; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public PickInfoUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 185;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public PickInfoUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public PickInfoUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PickInfoUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PickDeletePacket : Packet
    {
        /// <exclude/>
        [XmlType("pickdelete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("pickdelete_data")]
        public class DataBlock
        {
            public LLUUID PickID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PickID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("PickID: {0}", PickID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PickDelete; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public PickDeletePacket()
        {
            Header = new LowHeader();
            Header.ID = 186;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public PickDeletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public PickDeletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PickDelete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PickGodDeletePacket : Packet
    {
        /// <exclude/>
        [XmlType("pickgoddelete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("pickgoddelete_data")]
        public class DataBlock
        {
            public LLUUID PickID;
            public LLUUID QueryID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PickID = new LLUUID(bytes, i); i += 16;
                    QueryID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("PickID: {0}", PickID));
                output.Append(String.Format("QueryID: {0}", QueryID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PickGodDelete; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public PickGodDeletePacket()
        {
            Header = new LowHeader();
            Header.ID = 187;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public PickGodDeletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public PickGodDeletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PickGodDelete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptQuestionPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptquestion_data")]
        public class DataBlock
        {
            public LLUUID TaskID;
            public LLUUID ItemID;
            private byte[] _objectname;
            public byte[] ObjectName
            {
                get { return _objectname; }
                set
                {
                    if (value == null) { _objectname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
                }
            }
            private byte[] _objectowner;
            public byte[] ObjectOwner
            {
                get { return _objectowner; }
                set
                {
                    if (value == null) { _objectowner = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectowner = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectowner, 0, value.Length); }
                }
            }
            public int Questions;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 36;
                    if (ObjectName != null) { length += 1 + ObjectName.Length; }
                    if (ObjectOwner != null) { length += 1 + ObjectOwner.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TaskID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _objectname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _objectowner = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectowner, 0, length); i += length;
                    Questions = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectName.Length;
                Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
                if(ObjectOwner == null) { Console.WriteLine("Warning: ObjectOwner is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectOwner.Length;
                Buffer.BlockCopy(ObjectOwner, 0, bytes, i, ObjectOwner.Length); i += ObjectOwner.Length;
                bytes[i++] = (byte)(Questions % 256);
                bytes[i++] = (byte)((Questions >> 8) % 256);
                bytes[i++] = (byte)((Questions >> 16) % 256);
                bytes[i++] = (byte)((Questions >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TaskID: {0}", TaskID));
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                Helpers.FieldToString(output, ObjectName, "ObjectName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, ObjectOwner, "ObjectOwner");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Questions: {0}", Questions));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptQuestion; } }
        public DataBlock Data;

        public ScriptQuestionPacket()
        {
            Header = new LowHeader();
            Header.ID = 188;
            Header.Reliable = true;
            Data = new DataBlock();
        }

        public ScriptQuestionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
        }

        public ScriptQuestionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptQuestion ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptControlChangePacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptcontrolchange_data")]
        public class DataBlock
        {
            public bool TakeControls;
            public uint Controls;
            public bool PassToAgent;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 6;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TakeControls = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Controls = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PassToAgent = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((TakeControls) ? 1 : 0);
                bytes[i++] = (byte)(Controls % 256);
                bytes[i++] = (byte)((Controls >> 8) % 256);
                bytes[i++] = (byte)((Controls >> 16) % 256);
                bytes[i++] = (byte)((Controls >> 24) % 256);
                bytes[i++] = (byte)((PassToAgent) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("TakeControls: {0}", TakeControls));
                output.AppendLine(String.Format("Controls: {0}", Controls));
                output.Append(String.Format("PassToAgent: {0}", PassToAgent));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptControlChange; } }
        public DataBlock[] Data;

        public ScriptControlChangePacket()
        {
            Header = new LowHeader();
            Header.ID = 189;
            Header.Reliable = true;
            Data = new DataBlock[0];
        }

        public ScriptControlChangePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public ScriptControlChangePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptControlChange ---" + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ScriptDialogPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptdialog_data")]
        public class DataBlock
        {
            public LLUUID ObjectID;
            private byte[] _firstname;
            public byte[] FirstName
            {
                get { return _firstname; }
                set
                {
                    if (value == null) { _firstname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
                }
            }
            private byte[] _lastname;
            public byte[] LastName
            {
                get { return _lastname; }
                set
                {
                    if (value == null) { _lastname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
                }
            }
            private byte[] _objectname;
            public byte[] ObjectName
            {
                get { return _objectname; }
                set
                {
                    if (value == null) { _objectname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
                }
            }
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }
            public int ChatChannel;
            public LLUUID ImageID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 36;
                    if (FirstName != null) { length += 1 + FirstName.Length; }
                    if (LastName != null) { length += 1 + LastName.Length; }
                    if (ObjectName != null) { length += 1 + ObjectName.Length; }
                    if (Message != null) { length += 2 + Message.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _firstname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _lastname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _objectname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                    ChatChannel = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ImageID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FirstName.Length;
                Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
                if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
                bytes[i++] = (byte)LastName.Length;
                Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
                if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectName.Length;
                Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Message.Length % 256);
                bytes[i++] = (byte)((Message.Length >> 8) % 256);
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
                bytes[i++] = (byte)(ChatChannel % 256);
                bytes[i++] = (byte)((ChatChannel >> 8) % 256);
                bytes[i++] = (byte)((ChatChannel >> 16) % 256);
                bytes[i++] = (byte)((ChatChannel >> 24) % 256);
                Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                Helpers.FieldToString(output, FirstName, "FirstName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LastName, "LastName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, ObjectName, "ObjectName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Message, "Message");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ChatChannel: {0}", ChatChannel));
                output.Append(String.Format("ImageID: {0}", ImageID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("scriptdialog_buttons")]
        public class ButtonsBlock
        {
            private byte[] _buttonlabel;
            public byte[] ButtonLabel
            {
                get { return _buttonlabel; }
                set
                {
                    if (value == null) { _buttonlabel = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _buttonlabel = new byte[value.Length]; Buffer.BlockCopy(value, 0, _buttonlabel, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (ButtonLabel != null) { length += 1 + ButtonLabel.Length; }
                    return length;
                }
            }

            public ButtonsBlock() { }
            public ButtonsBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _buttonlabel = new byte[length];
                    Buffer.BlockCopy(bytes, i, _buttonlabel, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(ButtonLabel == null) { Console.WriteLine("Warning: ButtonLabel is null, in " + this.GetType()); }
                bytes[i++] = (byte)ButtonLabel.Length;
                Buffer.BlockCopy(ButtonLabel, 0, bytes, i, ButtonLabel.Length); i += ButtonLabel.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Buttons --");
                Helpers.FieldToString(output, ButtonLabel, "ButtonLabel");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptDialog; } }
        public DataBlock Data;
        public ButtonsBlock[] Buttons;

        public ScriptDialogPacket()
        {
            Header = new LowHeader();
            Header.ID = 190;
            Header.Reliable = true;
            Data = new DataBlock();
            Buttons = new ButtonsBlock[0];
        }

        public ScriptDialogPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Buttons = new ButtonsBlock[count];
            for (int j = 0; j < count; j++)
            { Buttons[j] = new ButtonsBlock(bytes, ref i); }
        }

        public ScriptDialogPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Buttons = new ButtonsBlock[count];
            for (int j = 0; j < count; j++)
            { Buttons[j] = new ButtonsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            length++;
            for (int j = 0; j < Buttons.Length; j++) { length += Buttons[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Buttons.Length;
            for (int j = 0; j < Buttons.Length; j++) { Buttons[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptDialog ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            for (int j = 0; j < Buttons.Length; j++)
            {
                output += Buttons[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ScriptDialogReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptdialogreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("scriptdialogreply_data")]
        public class DataBlock
        {
            public LLUUID ObjectID;
            public int ChatChannel;
            public int ButtonIndex;
            private byte[] _buttonlabel;
            public byte[] ButtonLabel
            {
                get { return _buttonlabel; }
                set
                {
                    if (value == null) { _buttonlabel = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _buttonlabel = new byte[value.Length]; Buffer.BlockCopy(value, 0, _buttonlabel, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (ButtonLabel != null) { length += 1 + ButtonLabel.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ChatChannel = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ButtonIndex = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _buttonlabel = new byte[length];
                    Buffer.BlockCopy(bytes, i, _buttonlabel, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ChatChannel % 256);
                bytes[i++] = (byte)((ChatChannel >> 8) % 256);
                bytes[i++] = (byte)((ChatChannel >> 16) % 256);
                bytes[i++] = (byte)((ChatChannel >> 24) % 256);
                bytes[i++] = (byte)(ButtonIndex % 256);
                bytes[i++] = (byte)((ButtonIndex >> 8) % 256);
                bytes[i++] = (byte)((ButtonIndex >> 16) % 256);
                bytes[i++] = (byte)((ButtonIndex >> 24) % 256);
                if(ButtonLabel == null) { Console.WriteLine("Warning: ButtonLabel is null, in " + this.GetType()); }
                bytes[i++] = (byte)ButtonLabel.Length;
                Buffer.BlockCopy(ButtonLabel, 0, bytes, i, ButtonLabel.Length); i += ButtonLabel.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("ChatChannel: {0}", ChatChannel));
                output.AppendLine(String.Format("ButtonIndex: {0}", ButtonIndex));
                Helpers.FieldToString(output, ButtonLabel, "ButtonLabel");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptDialogReply; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ScriptDialogReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 191;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ScriptDialogReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ScriptDialogReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptDialogReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ForceScriptControlReleasePacket : Packet
    {
        /// <exclude/>
        [XmlType("forcescriptcontrolrelease_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ForceScriptControlRelease; } }
        public AgentDataBlock AgentData;

        public ForceScriptControlReleasePacket()
        {
            Header = new LowHeader();
            Header.ID = 192;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ForceScriptControlReleasePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ForceScriptControlReleasePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ForceScriptControlRelease ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RevokePermissionsPacket : Packet
    {
        /// <exclude/>
        [XmlType("revokepermissions_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("revokepermissions_data")]
        public class DataBlock
        {
            public LLUUID ObjectID;
            public uint ObjectPermissions;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ObjectPermissions = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ObjectPermissions % 256);
                bytes[i++] = (byte)((ObjectPermissions >> 8) % 256);
                bytes[i++] = (byte)((ObjectPermissions >> 16) % 256);
                bytes[i++] = (byte)((ObjectPermissions >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("ObjectPermissions: {0}", ObjectPermissions));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RevokePermissions; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public RevokePermissionsPacket()
        {
            Header = new LowHeader();
            Header.ID = 193;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public RevokePermissionsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public RevokePermissionsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RevokePermissions ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LoadURLPacket : Packet
    {
        /// <exclude/>
        [XmlType("loadurl_data")]
        public class DataBlock
        {
            private byte[] _objectname;
            public byte[] ObjectName
            {
                get { return _objectname; }
                set
                {
                    if (value == null) { _objectname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
                }
            }
            public LLUUID ObjectID;
            public LLUUID OwnerID;
            public bool OwnerIsGroup;
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }
            private byte[] _url;
            public byte[] URL
            {
                get { return _url; }
                set
                {
                    if (value == null) { _url = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _url = new byte[value.Length]; Buffer.BlockCopy(value, 0, _url, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 33;
                    if (ObjectName != null) { length += 1 + ObjectName.Length; }
                    if (Message != null) { length += 1 + Message.Length; }
                    if (URL != null) { length += 1 + URL.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _objectname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    OwnerIsGroup = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _url = new byte[length];
                    Buffer.BlockCopy(bytes, i, _url, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectName.Length;
                Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((OwnerIsGroup) ? 1 : 0);
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)Message.Length;
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
                if(URL == null) { Console.WriteLine("Warning: URL is null, in " + this.GetType()); }
                bytes[i++] = (byte)URL.Length;
                Buffer.BlockCopy(URL, 0, bytes, i, URL.Length); i += URL.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                Helpers.FieldToString(output, ObjectName, "ObjectName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("OwnerIsGroup: {0}", OwnerIsGroup));
                Helpers.FieldToString(output, Message, "Message");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, URL, "URL");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LoadURL; } }
        public DataBlock Data;

        public LoadURLPacket()
        {
            Header = new LowHeader();
            Header.ID = 194;
            Header.Reliable = true;
            Data = new DataBlock();
        }

        public LoadURLPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
        }

        public LoadURLPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LoadURL ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptTeleportRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptteleportrequest_data")]
        public class DataBlock
        {
            private byte[] _objectname;
            public byte[] ObjectName
            {
                get { return _objectname; }
                set
                {
                    if (value == null) { _objectname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
                }
            }
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public LLVector3 SimPosition;
            public LLVector3 LookAt;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (ObjectName != null) { length += 1 + ObjectName.Length; }
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _objectname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    SimPosition = new LLVector3(bytes, i); i += 12;
                    LookAt = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectName.Length;
                Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                Buffer.BlockCopy(SimPosition.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                Helpers.FieldToString(output, ObjectName, "ObjectName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("SimPosition: {0}", SimPosition));
                output.Append(String.Format("LookAt: {0}", LookAt));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptTeleportRequest; } }
        public DataBlock Data;

        public ScriptTeleportRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 195;
            Header.Reliable = true;
            Data = new DataBlock();
        }

        public ScriptTeleportRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
        }

        public ScriptTeleportRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptTeleportRequest ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelOverlayPacket : Packet
    {
        /// <exclude/>
        [XmlType("parceloverlay_parceldata")]
        public class ParcelDataBlock
        {
            public int SequenceID;
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelOverlay; } }
        public ParcelDataBlock ParcelData;

        public ParcelOverlayPacket()
        {
            Header = new LowHeader();
            Header.ID = 196;
            Header.Reliable = true;
            ParcelData = new ParcelDataBlock();
        }

        public ParcelOverlayPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelOverlayPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelOverlay ---" + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelPropertiesRequestByIDPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelpropertiesrequestbyid_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelpropertiesrequestbyid_parceldata")]
        public class ParcelDataBlock
        {
            public int SequenceID;
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelPropertiesRequestByID; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelPropertiesRequestByIDPacket()
        {
            Header = new LowHeader();
            Header.ID = 197;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelPropertiesRequestByIDPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelPropertiesRequestByIDPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelPropertiesRequestByID ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelPropertiesUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelpropertiesupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelpropertiesupdate_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public uint Flags;
            public uint ParcelFlags;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            private byte[] _musicurl;
            public byte[] MusicURL
            {
                get { return _musicurl; }
                set
                {
                    if (value == null) { _musicurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _musicurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _musicurl, 0, value.Length); }
                }
            }
            private byte[] _mediaurl;
            public byte[] MediaURL
            {
                get { return _mediaurl; }
                set
                {
                    if (value == null) { _mediaurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
                }
            }
            public LLUUID MediaID;
            public byte MediaAutoScale;
            public LLUUID GroupID;
            public int PassPrice;
            public float PassHours;
            public byte Category;
            public LLUUID AuthBuyerID;
            public LLUUID SnapshotID;
            public LLVector3 UserLocation;
            public LLVector3 UserLookAt;
            public byte LandingType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 115;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 1 + Desc.Length; }
                    if (MusicURL != null) { length += 1 + MusicURL.Length; }
                    if (MediaURL != null) { length += 1 + MediaURL.Length; }
                    return length;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParcelFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _musicurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _musicurl, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _mediaurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
                    MediaID = new LLUUID(bytes, i); i += 16;
                    MediaAutoScale = (byte)bytes[i++];
                    GroupID = new LLUUID(bytes, i); i += 16;
                    PassPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    PassHours = BitConverter.ToSingle(bytes, i); i += 4;
                    Category = (byte)bytes[i++];
                    AuthBuyerID = new LLUUID(bytes, i); i += 16;
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    UserLocation = new LLVector3(bytes, i); i += 12;
                    UserLookAt = new LLVector3(bytes, i); i += 12;
                    LandingType = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(ParcelFlags % 256);
                bytes[i++] = (byte)((ParcelFlags >> 8) % 256);
                bytes[i++] = (byte)((ParcelFlags >> 16) % 256);
                bytes[i++] = (byte)((ParcelFlags >> 24) % 256);
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)Desc.Length;
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                if(MusicURL == null) { Console.WriteLine("Warning: MusicURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MusicURL.Length;
                Buffer.BlockCopy(MusicURL, 0, bytes, i, MusicURL.Length); i += MusicURL.Length;
                if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MediaURL.Length;
                Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
                Buffer.BlockCopy(MediaID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = MediaAutoScale;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(PassPrice % 256);
                bytes[i++] = (byte)((PassPrice >> 8) % 256);
                bytes[i++] = (byte)((PassPrice >> 16) % 256);
                bytes[i++] = (byte)((PassPrice >> 24) % 256);
                ba = BitConverter.GetBytes(PassHours);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = Category;
                Buffer.BlockCopy(AuthBuyerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(UserLocation.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(UserLookAt.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = LandingType;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("ParcelFlags: {0}", ParcelFlags));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, MusicURL, "MusicURL");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, MediaURL, "MediaURL");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("MediaID: {0}", MediaID));
                output.AppendLine(String.Format("MediaAutoScale: {0}", MediaAutoScale));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("PassPrice: {0}", PassPrice));
                output.AppendLine(String.Format("PassHours: {0}", PassHours));
                output.AppendLine(String.Format("Category: {0}", Category));
                output.AppendLine(String.Format("AuthBuyerID: {0}", AuthBuyerID));
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                output.AppendLine(String.Format("UserLocation: {0}", UserLocation));
                output.AppendLine(String.Format("UserLookAt: {0}", UserLookAt));
                output.Append(String.Format("LandingType: {0}", LandingType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelPropertiesUpdate; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelPropertiesUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 198;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelPropertiesUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelPropertiesUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelPropertiesUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelReturnObjectsPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelreturnobjects_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelreturnobjects_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public uint ReturnType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ReturnType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)(ReturnType % 256);
                bytes[i++] = (byte)((ReturnType >> 8) % 256);
                bytes[i++] = (byte)((ReturnType >> 16) % 256);
                bytes[i++] = (byte)((ReturnType >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("ReturnType: {0}", ReturnType));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelreturnobjects_taskids")]
        public class TaskIDsBlock
        {
            public LLUUID TaskID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TaskIDsBlock() { }
            public TaskIDsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TaskID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TaskIDs --");
                output.Append(String.Format("TaskID: {0}", TaskID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelreturnobjects_ownerids")]
        public class OwnerIDsBlock
        {
            public LLUUID OwnerID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public OwnerIDsBlock() { }
            public OwnerIDsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- OwnerIDs --");
                output.Append(String.Format("OwnerID: {0}", OwnerID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelReturnObjects; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;
        public TaskIDsBlock[] TaskIDs;
        public OwnerIDsBlock[] OwnerIDs;

        public ParcelReturnObjectsPacket()
        {
            Header = new LowHeader();
            Header.ID = 199;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
            TaskIDs = new TaskIDsBlock[0];
            OwnerIDs = new OwnerIDsBlock[0];
        }

        public ParcelReturnObjectsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            TaskIDs = new TaskIDsBlock[count];
            for (int j = 0; j < count; j++)
            { TaskIDs[j] = new TaskIDsBlock(bytes, ref i); }
            count = (int)bytes[i++];
            OwnerIDs = new OwnerIDsBlock[count];
            for (int j = 0; j < count; j++)
            { OwnerIDs[j] = new OwnerIDsBlock(bytes, ref i); }
        }

        public ParcelReturnObjectsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            TaskIDs = new TaskIDsBlock[count];
            for (int j = 0; j < count; j++)
            { TaskIDs[j] = new TaskIDsBlock(bytes, ref i); }
            count = (int)bytes[i++];
            OwnerIDs = new OwnerIDsBlock[count];
            for (int j = 0; j < count; j++)
            { OwnerIDs[j] = new OwnerIDsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            length++;
            for (int j = 0; j < TaskIDs.Length; j++) { length += TaskIDs[j].Length; }
            length++;
            for (int j = 0; j < OwnerIDs.Length; j++) { length += OwnerIDs[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)TaskIDs.Length;
            for (int j = 0; j < TaskIDs.Length; j++) { TaskIDs[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)OwnerIDs.Length;
            for (int j = 0; j < OwnerIDs.Length; j++) { OwnerIDs[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelReturnObjects ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            for (int j = 0; j < TaskIDs.Length; j++)
            {
                output += TaskIDs[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < OwnerIDs.Length; j++)
            {
                output += OwnerIDs[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelSetOtherCleanTimePacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelsetothercleantime_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelsetothercleantime_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public int OtherCleanTime;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OtherCleanTime = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)(OtherCleanTime % 256);
                bytes[i++] = (byte)((OtherCleanTime >> 8) % 256);
                bytes[i++] = (byte)((OtherCleanTime >> 16) % 256);
                bytes[i++] = (byte)((OtherCleanTime >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("OtherCleanTime: {0}", OtherCleanTime));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelSetOtherCleanTime; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelSetOtherCleanTimePacket()
        {
            Header = new LowHeader();
            Header.ID = 200;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelSetOtherCleanTimePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelSetOtherCleanTimePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelSetOtherCleanTime ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelDisableObjectsPacket : Packet
    {
        /// <exclude/>
        [XmlType("parceldisableobjects_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldisableobjects_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public uint ReturnType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ReturnType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)(ReturnType % 256);
                bytes[i++] = (byte)((ReturnType >> 8) % 256);
                bytes[i++] = (byte)((ReturnType >> 16) % 256);
                bytes[i++] = (byte)((ReturnType >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("ReturnType: {0}", ReturnType));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldisableobjects_taskids")]
        public class TaskIDsBlock
        {
            public LLUUID TaskID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TaskIDsBlock() { }
            public TaskIDsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TaskID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TaskIDs --");
                output.Append(String.Format("TaskID: {0}", TaskID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldisableobjects_ownerids")]
        public class OwnerIDsBlock
        {
            public LLUUID OwnerID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public OwnerIDsBlock() { }
            public OwnerIDsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- OwnerIDs --");
                output.Append(String.Format("OwnerID: {0}", OwnerID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelDisableObjects; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;
        public TaskIDsBlock[] TaskIDs;
        public OwnerIDsBlock[] OwnerIDs;

        public ParcelDisableObjectsPacket()
        {
            Header = new LowHeader();
            Header.ID = 201;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
            TaskIDs = new TaskIDsBlock[0];
            OwnerIDs = new OwnerIDsBlock[0];
        }

        public ParcelDisableObjectsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            TaskIDs = new TaskIDsBlock[count];
            for (int j = 0; j < count; j++)
            { TaskIDs[j] = new TaskIDsBlock(bytes, ref i); }
            count = (int)bytes[i++];
            OwnerIDs = new OwnerIDsBlock[count];
            for (int j = 0; j < count; j++)
            { OwnerIDs[j] = new OwnerIDsBlock(bytes, ref i); }
        }

        public ParcelDisableObjectsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            TaskIDs = new TaskIDsBlock[count];
            for (int j = 0; j < count; j++)
            { TaskIDs[j] = new TaskIDsBlock(bytes, ref i); }
            count = (int)bytes[i++];
            OwnerIDs = new OwnerIDsBlock[count];
            for (int j = 0; j < count; j++)
            { OwnerIDs[j] = new OwnerIDsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            length++;
            for (int j = 0; j < TaskIDs.Length; j++) { length += TaskIDs[j].Length; }
            length++;
            for (int j = 0; j < OwnerIDs.Length; j++) { length += OwnerIDs[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)TaskIDs.Length;
            for (int j = 0; j < TaskIDs.Length; j++) { TaskIDs[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)OwnerIDs.Length;
            for (int j = 0; j < OwnerIDs.Length; j++) { OwnerIDs[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelDisableObjects ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            for (int j = 0; j < TaskIDs.Length; j++)
            {
                output += TaskIDs[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < OwnerIDs.Length; j++)
            {
                output += OwnerIDs[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelSelectObjectsPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelselectobjects_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelselectobjects_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public uint ReturnType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ReturnType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)(ReturnType % 256);
                bytes[i++] = (byte)((ReturnType >> 8) % 256);
                bytes[i++] = (byte)((ReturnType >> 16) % 256);
                bytes[i++] = (byte)((ReturnType >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("ReturnType: {0}", ReturnType));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelselectobjects_returnids")]
        public class ReturnIDsBlock
        {
            public LLUUID ReturnID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ReturnIDsBlock() { }
            public ReturnIDsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ReturnID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ReturnID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ReturnIDs --");
                output.Append(String.Format("ReturnID: {0}", ReturnID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelSelectObjects; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;
        public ReturnIDsBlock[] ReturnIDs;

        public ParcelSelectObjectsPacket()
        {
            Header = new LowHeader();
            Header.ID = 202;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
            ReturnIDs = new ReturnIDsBlock[0];
        }

        public ParcelSelectObjectsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ReturnIDs = new ReturnIDsBlock[count];
            for (int j = 0; j < count; j++)
            { ReturnIDs[j] = new ReturnIDsBlock(bytes, ref i); }
        }

        public ParcelSelectObjectsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ReturnIDs = new ReturnIDsBlock[count];
            for (int j = 0; j < count; j++)
            { ReturnIDs[j] = new ReturnIDsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            length++;
            for (int j = 0; j < ReturnIDs.Length; j++) { length += ReturnIDs[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ReturnIDs.Length;
            for (int j = 0; j < ReturnIDs.Length; j++) { ReturnIDs[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelSelectObjects ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            for (int j = 0; j < ReturnIDs.Length; j++)
            {
                output += ReturnIDs[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class EstateCovenantRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("estatecovenantrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EstateCovenantRequest; } }
        public AgentDataBlock AgentData;

        public EstateCovenantRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 203;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public EstateCovenantRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public EstateCovenantRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EstateCovenantRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EstateCovenantReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("estatecovenantreply_data")]
        public class DataBlock
        {
            public LLUUID CovenantID;
            public uint CovenantTimestamp;
            private byte[] _estatename;
            public byte[] EstateName
            {
                get { return _estatename; }
                set
                {
                    if (value == null) { _estatename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _estatename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _estatename, 0, value.Length); }
                }
            }
            public LLUUID EstateOwnerID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 36;
                    if (EstateName != null) { length += 1 + EstateName.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    CovenantID = new LLUUID(bytes, i); i += 16;
                    CovenantTimestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _estatename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _estatename, 0, length); i += length;
                    EstateOwnerID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(CovenantID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CovenantTimestamp % 256);
                bytes[i++] = (byte)((CovenantTimestamp >> 8) % 256);
                bytes[i++] = (byte)((CovenantTimestamp >> 16) % 256);
                bytes[i++] = (byte)((CovenantTimestamp >> 24) % 256);
                if(EstateName == null) { Console.WriteLine("Warning: EstateName is null, in " + this.GetType()); }
                bytes[i++] = (byte)EstateName.Length;
                Buffer.BlockCopy(EstateName, 0, bytes, i, EstateName.Length); i += EstateName.Length;
                Buffer.BlockCopy(EstateOwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("CovenantID: {0}", CovenantID));
                output.AppendLine(String.Format("CovenantTimestamp: {0}", CovenantTimestamp));
                Helpers.FieldToString(output, EstateName, "EstateName");
                output.Append(Environment.NewLine);
                output.Append(String.Format("EstateOwnerID: {0}", EstateOwnerID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EstateCovenantReply; } }
        public DataBlock Data;

        public EstateCovenantReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 204;
            Header.Reliable = true;
            Data = new DataBlock();
        }

        public EstateCovenantReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
        }

        public EstateCovenantReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EstateCovenantReply ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ForceObjectSelectPacket : Packet
    {
        /// <exclude/>
        [XmlType("forceobjectselect_header")]
        public class HeaderBlock
        {
            public bool ResetList;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public HeaderBlock() { }
            public HeaderBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ResetList = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((ResetList) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Header --");
                output.Append(String.Format("ResetList: {0}", ResetList));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("forceobjectselect_data")]
        public class DataBlock
        {
            public uint LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ForceObjectSelect; } }
        public HeaderBlock _Header;
        public DataBlock[] Data;

        public ForceObjectSelectPacket()
        {
            Header = new LowHeader();
            Header.ID = 205;
            Header.Reliable = true;
            _Header = new HeaderBlock();
            Data = new DataBlock[0];
        }

        public ForceObjectSelectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            _Header = new HeaderBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public ForceObjectSelectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            _Header = new HeaderBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += _Header.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            _Header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ForceObjectSelect ---" + Environment.NewLine;
                output += _Header.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelBuyPassPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelbuypass_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelbuypass_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelBuyPass; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelBuyPassPacket()
        {
            Header = new LowHeader();
            Header.ID = 206;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelBuyPassPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelBuyPassPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelBuyPass ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelDeedToGroupPacket : Packet
    {
        /// <exclude/>
        [XmlType("parceldeedtogroup_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldeedtogroup_data")]
        public class DataBlock
        {
            public LLUUID GroupID;
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelDeedToGroup; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelDeedToGroupPacket()
        {
            Header = new LowHeader();
            Header.ID = 207;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelDeedToGroupPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelDeedToGroupPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelDeedToGroup ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelReclaimPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelreclaim_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelreclaim_data")]
        public class DataBlock
        {
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelReclaim; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelReclaimPacket()
        {
            Header = new LowHeader();
            Header.ID = 208;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelReclaimPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelReclaimPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelReclaim ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelClaimPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelclaim_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelclaim_data")]
        public class DataBlock
        {
            public LLUUID GroupID;
            public bool IsGroupOwned;
            public bool Final;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 18;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Final = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
                bytes[i++] = (byte)((Final) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
                output.Append(String.Format("Final: {0}", Final));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelclaim_parceldata")]
        public class ParcelDataBlock
        {
            public float West;
            public float South;
            public float East;
            public float North;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    West = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    South = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    East = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    North = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                ba = BitConverter.GetBytes(West);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(South);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(East);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(North);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("West: {0}", West));
                output.AppendLine(String.Format("South: {0}", South));
                output.AppendLine(String.Format("East: {0}", East));
                output.Append(String.Format("North: {0}", North));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelClaim; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;
        public ParcelDataBlock[] ParcelData;

        public ParcelClaimPacket()
        {
            Header = new LowHeader();
            Header.ID = 209;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
            ParcelData = new ParcelDataBlock[0];
        }

        public ParcelClaimPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParcelData = new ParcelDataBlock[count];
            for (int j = 0; j < count; j++)
            { ParcelData[j] = new ParcelDataBlock(bytes, ref i); }
        }

        public ParcelClaimPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParcelData = new ParcelDataBlock[count];
            for (int j = 0; j < count; j++)
            { ParcelData[j] = new ParcelDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            length++;
            for (int j = 0; j < ParcelData.Length; j++) { length += ParcelData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ParcelData.Length;
            for (int j = 0; j < ParcelData.Length; j++) { ParcelData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelClaim ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            for (int j = 0; j < ParcelData.Length; j++)
            {
                output += ParcelData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelJoinPacket : Packet
    {
        /// <exclude/>
        [XmlType("parceljoin_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceljoin_parceldata")]
        public class ParcelDataBlock
        {
            public float West;
            public float South;
            public float East;
            public float North;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    West = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    South = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    East = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    North = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                ba = BitConverter.GetBytes(West);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(South);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(East);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(North);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("West: {0}", West));
                output.AppendLine(String.Format("South: {0}", South));
                output.AppendLine(String.Format("East: {0}", East));
                output.Append(String.Format("North: {0}", North));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelJoin; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelJoinPacket()
        {
            Header = new LowHeader();
            Header.ID = 210;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelJoinPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelJoinPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelJoin ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelDividePacket : Packet
    {
        /// <exclude/>
        [XmlType("parceldivide_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldivide_parceldata")]
        public class ParcelDataBlock
        {
            public float West;
            public float South;
            public float East;
            public float North;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    West = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    South = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    East = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    North = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                ba = BitConverter.GetBytes(West);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(South);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(East);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(North);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("West: {0}", West));
                output.AppendLine(String.Format("South: {0}", South));
                output.AppendLine(String.Format("East: {0}", East));
                output.Append(String.Format("North: {0}", North));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelDivide; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelDividePacket()
        {
            Header = new LowHeader();
            Header.ID = 211;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelDividePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelDividePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelDivide ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelReleasePacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelrelease_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelrelease_data")]
        public class DataBlock
        {
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelRelease; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelReleasePacket()
        {
            Header = new LowHeader();
            Header.ID = 212;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelReleasePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelReleasePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelRelease ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelBuyPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelbuy_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelbuy_data")]
        public class DataBlock
        {
            public LLUUID GroupID;
            public bool IsGroupOwned;
            public bool RemoveContribution;
            public int LocalID;
            public bool Final;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 23;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RemoveContribution = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Final = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
                bytes[i++] = (byte)((RemoveContribution) ? 1 : 0);
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = (byte)((Final) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
                output.AppendLine(String.Format("RemoveContribution: {0}", RemoveContribution));
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("Final: {0}", Final));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelbuy_parceldata")]
        public class ParcelDataBlock
        {
            public int Price;
            public int Area;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Price = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Area = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Price % 256);
                bytes[i++] = (byte)((Price >> 8) % 256);
                bytes[i++] = (byte)((Price >> 16) % 256);
                bytes[i++] = (byte)((Price >> 24) % 256);
                bytes[i++] = (byte)(Area % 256);
                bytes[i++] = (byte)((Area >> 8) % 256);
                bytes[i++] = (byte)((Area >> 16) % 256);
                bytes[i++] = (byte)((Area >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("Price: {0}", Price));
                output.Append(String.Format("Area: {0}", Area));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelBuy; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;
        public ParcelDataBlock ParcelData;

        public ParcelBuyPacket()
        {
            Header = new LowHeader();
            Header.ID = 213;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelBuyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelBuyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelBuy ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelGodForceOwnerPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelgodforceowner_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelgodforceowner_data")]
        public class DataBlock
        {
            public LLUUID OwnerID;
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelGodForceOwner; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelGodForceOwnerPacket()
        {
            Header = new LowHeader();
            Header.ID = 214;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelGodForceOwnerPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelGodForceOwnerPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelGodForceOwner ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelAccessListRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelaccesslistrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelaccesslistrequest_data")]
        public class DataBlock
        {
            public int SequenceID;
            public uint Flags;
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelAccessListRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelAccessListRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 215;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelAccessListRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelAccessListRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelAccessListRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelAccessListReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelaccesslistreply_data")]
        public class DataBlock
        {
            public LLUUID AgentID;
            public int SequenceID;
            public uint Flags;
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 28;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelaccesslistreply_list")]
        public class ListBlock
        {
            public LLUUID ID;
            public int Time;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public ListBlock() { }
            public ListBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    Time = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Time % 256);
                bytes[i++] = (byte)((Time >> 8) % 256);
                bytes[i++] = (byte)((Time >> 16) % 256);
                bytes[i++] = (byte)((Time >> 24) % 256);
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- List --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("Time: {0}", Time));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelAccessListReply; } }
        public DataBlock Data;
        public ListBlock[] List;

        public ParcelAccessListReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 216;
            Header.Reliable = true;
            Data = new DataBlock();
            List = new ListBlock[0];
        }

        public ParcelAccessListReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            List = new ListBlock[count];
            for (int j = 0; j < count; j++)
            { List[j] = new ListBlock(bytes, ref i); }
        }

        public ParcelAccessListReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            List = new ListBlock[count];
            for (int j = 0; j < count; j++)
            { List[j] = new ListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Data.Length;;
            length++;
            for (int j = 0; j < List.Length; j++) { length += List[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            bytes[i++] = (byte)List.Length;
            for (int j = 0; j < List.Length; j++) { List[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelAccessListReply ---" + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            for (int j = 0; j < List.Length; j++)
            {
                output += List[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelAccessListUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelaccesslistupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelaccesslistupdate_data")]
        public class DataBlock
        {
            public uint Flags;
            public int LocalID;
            public LLUUID TransactionID;
            public int SequenceID;
            public int Sections;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Sections = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                bytes[i++] = (byte)(Sections % 256);
                bytes[i++] = (byte)((Sections >> 8) % 256);
                bytes[i++] = (byte)((Sections >> 16) % 256);
                bytes[i++] = (byte)((Sections >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                output.Append(String.Format("Sections: {0}", Sections));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelaccesslistupdate_list")]
        public class ListBlock
        {
            public LLUUID ID;
            public int Time;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public ListBlock() { }
            public ListBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    Time = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Time % 256);
                bytes[i++] = (byte)((Time >> 8) % 256);
                bytes[i++] = (byte)((Time >> 16) % 256);
                bytes[i++] = (byte)((Time >> 24) % 256);
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- List --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("Time: {0}", Time));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelAccessListUpdate; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;
        public ListBlock[] List;

        public ParcelAccessListUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 217;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
            List = new ListBlock[0];
        }

        public ParcelAccessListUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            List = new ListBlock[count];
            for (int j = 0; j < count; j++)
            { List[j] = new ListBlock(bytes, ref i); }
        }

        public ParcelAccessListUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            List = new ListBlock[count];
            for (int j = 0; j < count; j++)
            { List[j] = new ListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            length++;
            for (int j = 0; j < List.Length; j++) { length += List[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            bytes[i++] = (byte)List.Length;
            for (int j = 0; j < List.Length; j++) { List[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelAccessListUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            for (int j = 0; j < List.Length; j++)
            {
                output += List[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ParcelDwellRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("parceldwellrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldwellrequest_data")]
        public class DataBlock
        {
            public int LocalID;
            public LLUUID ParcelID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParcelID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("ParcelID: {0}", ParcelID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelDwellRequest; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelDwellRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 218;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelDwellRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelDwellRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelDwellRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelDwellReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("parceldwellreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parceldwellreply_data")]
        public class DataBlock
        {
            public int LocalID;
            public LLUUID ParcelID;
            public float Dwell;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParcelID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Dwell = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(Dwell);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
                output.Append(String.Format("Dwell: {0}", Dwell));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelDwellReply; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ParcelDwellReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 219;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ParcelDwellReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ParcelDwellReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelDwellReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelGodMarkAsContentPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelgodmarkascontent_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelgodmarkascontent_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelGodMarkAsContent; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelGodMarkAsContentPacket()
        {
            Header = new LowHeader();
            Header.ID = 227;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelGodMarkAsContentPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelGodMarkAsContentPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelGodMarkAsContent ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ViewerStartAuctionPacket : Packet
    {
        /// <exclude/>
        [XmlType("viewerstartauction_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("viewerstartauction_parceldata")]
        public class ParcelDataBlock
        {
            public int LocalID;
            public LLUUID SnapshotID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("SnapshotID: {0}", SnapshotID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ViewerStartAuction; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ViewerStartAuctionPacket()
        {
            Header = new LowHeader();
            Header.ID = 228;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ViewerStartAuctionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ViewerStartAuctionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ViewerStartAuction ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UUIDNameRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("uuidnamerequest_uuidnameblock")]
        public class UUIDNameBlockBlock
        {
            public LLUUID ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public UUIDNameBlockBlock() { }
            public UUIDNameBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UUIDNameBlock --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UUIDNameRequest; } }
        public UUIDNameBlockBlock[] UUIDNameBlock;

        public UUIDNameRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 235;
            Header.Reliable = true;
            UUIDNameBlock = new UUIDNameBlockBlock[0];
        }

        public UUIDNameRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public UUIDNameRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)UUIDNameBlock.Length;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UUIDNameRequest ---" + Environment.NewLine;
            for (int j = 0; j < UUIDNameBlock.Length; j++)
            {
                output += UUIDNameBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UUIDNameReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("uuidnamereply_uuidnameblock")]
        public class UUIDNameBlockBlock
        {
            public LLUUID ID;
            private byte[] _firstname;
            public byte[] FirstName
            {
                get { return _firstname; }
                set
                {
                    if (value == null) { _firstname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
                }
            }
            private byte[] _lastname;
            public byte[] LastName
            {
                get { return _lastname; }
                set
                {
                    if (value == null) { _lastname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (FirstName != null) { length += 1 + FirstName.Length; }
                    if (LastName != null) { length += 1 + LastName.Length; }
                    return length;
                }
            }

            public UUIDNameBlockBlock() { }
            public UUIDNameBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _firstname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _lastname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FirstName.Length;
                Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
                if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
                bytes[i++] = (byte)LastName.Length;
                Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UUIDNameBlock --");
                output.AppendLine(String.Format("ID: {0}", ID));
                Helpers.FieldToString(output, FirstName, "FirstName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LastName, "LastName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UUIDNameReply; } }
        public UUIDNameBlockBlock[] UUIDNameBlock;

        public UUIDNameReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 236;
            Header.Reliable = true;
            UUIDNameBlock = new UUIDNameBlockBlock[0];
        }

        public UUIDNameReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public UUIDNameReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)UUIDNameBlock.Length;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UUIDNameReply ---" + Environment.NewLine;
            for (int j = 0; j < UUIDNameBlock.Length; j++)
            {
                output += UUIDNameBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UUIDGroupNameRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("uuidgroupnamerequest_uuidnameblock")]
        public class UUIDNameBlockBlock
        {
            public LLUUID ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public UUIDNameBlockBlock() { }
            public UUIDNameBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UUIDNameBlock --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UUIDGroupNameRequest; } }
        public UUIDNameBlockBlock[] UUIDNameBlock;

        public UUIDGroupNameRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 237;
            Header.Reliable = true;
            UUIDNameBlock = new UUIDNameBlockBlock[0];
        }

        public UUIDGroupNameRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public UUIDGroupNameRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)UUIDNameBlock.Length;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UUIDGroupNameRequest ---" + Environment.NewLine;
            for (int j = 0; j < UUIDNameBlock.Length; j++)
            {
                output += UUIDNameBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UUIDGroupNameReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("uuidgroupnamereply_uuidnameblock")]
        public class UUIDNameBlockBlock
        {
            public LLUUID ID;
            private byte[] _groupname;
            public byte[] GroupName
            {
                get { return _groupname; }
                set
                {
                    if (value == null) { _groupname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (GroupName != null) { length += 1 + GroupName.Length; }
                    return length;
                }
            }

            public UUIDNameBlockBlock() { }
            public UUIDNameBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _groupname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupName.Length;
                Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UUIDNameBlock --");
                output.AppendLine(String.Format("ID: {0}", ID));
                Helpers.FieldToString(output, GroupName, "GroupName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UUIDGroupNameReply; } }
        public UUIDNameBlockBlock[] UUIDNameBlock;

        public UUIDGroupNameReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 238;
            Header.Reliable = true;
            UUIDNameBlock = new UUIDNameBlockBlock[0];
        }

        public UUIDGroupNameReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public UUIDGroupNameReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            UUIDNameBlock = new UUIDNameBlockBlock[count];
            for (int j = 0; j < count; j++)
            { UUIDNameBlock[j] = new UUIDNameBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)UUIDNameBlock.Length;
            for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UUIDGroupNameReply ---" + Environment.NewLine;
            for (int j = 0; j < UUIDNameBlock.Length; j++)
            {
                output += UUIDNameBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ChildAgentDyingPacket : Packet
    {
        /// <exclude/>
        [XmlType("childagentdying_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChildAgentDying; } }
        public AgentDataBlock AgentData;

        public ChildAgentDyingPacket()
        {
            Header = new LowHeader();
            Header.ID = 240;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ChildAgentDyingPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ChildAgentDyingPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChildAgentDying ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ChildAgentUnknownPacket : Packet
    {
        /// <exclude/>
        [XmlType("childagentunknown_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChildAgentUnknown; } }
        public AgentDataBlock AgentData;

        public ChildAgentUnknownPacket()
        {
            Header = new LowHeader();
            Header.ID = 241;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ChildAgentUnknownPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ChildAgentUnknownPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChildAgentUnknown ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GetScriptRunningPacket : Packet
    {
        /// <exclude/>
        [XmlType("getscriptrunning_script")]
        public class ScriptBlock
        {
            public LLUUID ObjectID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public ScriptBlock() { }
            public ScriptBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Script --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GetScriptRunning; } }
        public ScriptBlock Script;

        public GetScriptRunningPacket()
        {
            Header = new LowHeader();
            Header.ID = 243;
            Header.Reliable = true;
            Script = new ScriptBlock();
        }

        public GetScriptRunningPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Script = new ScriptBlock(bytes, ref i);
        }

        public GetScriptRunningPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Script = new ScriptBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Script.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Script.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GetScriptRunning ---" + Environment.NewLine;
                output += Script.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptRunningReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptrunningreply_script")]
        public class ScriptBlock
        {
            public LLUUID ObjectID;
            public LLUUID ItemID;
            public bool Running;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public ScriptBlock() { }
            public ScriptBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                    Running = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Running) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Script --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("Running: {0}", Running));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptRunningReply; } }
        public ScriptBlock Script;

        public ScriptRunningReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 244;
            Header.Reliable = true;
            Script = new ScriptBlock();
        }

        public ScriptRunningReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Script = new ScriptBlock(bytes, ref i);
        }

        public ScriptRunningReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Script = new ScriptBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Script.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Script.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptRunningReply ---" + Environment.NewLine;
                output += Script.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SetScriptRunningPacket : Packet
    {
        /// <exclude/>
        [XmlType("setscriptrunning_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("setscriptrunning_script")]
        public class ScriptBlock
        {
            public LLUUID ObjectID;
            public LLUUID ItemID;
            public bool Running;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public ScriptBlock() { }
            public ScriptBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                    Running = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Running) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Script --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("Running: {0}", Running));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SetScriptRunning; } }
        public AgentDataBlock AgentData;
        public ScriptBlock Script;

        public SetScriptRunningPacket()
        {
            Header = new LowHeader();
            Header.ID = 245;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Script = new ScriptBlock();
        }

        public SetScriptRunningPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Script = new ScriptBlock(bytes, ref i);
        }

        public SetScriptRunningPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Script = new ScriptBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Script.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Script.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SetScriptRunning ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Script.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptResetPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptreset_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("scriptreset_script")]
        public class ScriptBlock
        {
            public LLUUID ObjectID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public ScriptBlock() { }
            public ScriptBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Script --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptReset; } }
        public AgentDataBlock AgentData;
        public ScriptBlock Script;

        public ScriptResetPacket()
        {
            Header = new LowHeader();
            Header.ID = 246;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Script = new ScriptBlock();
        }

        public ScriptResetPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Script = new ScriptBlock(bytes, ref i);
        }

        public ScriptResetPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Script = new ScriptBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Script.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Script.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptReset ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Script.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptSensorRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptsensorrequest_requester")]
        public class RequesterBlock
        {
            public LLUUID SourceID;
            public LLUUID RequestID;
            public LLUUID SearchID;
            public LLVector3 SearchPos;
            public LLQuaternion SearchDir;
            private byte[] _searchname;
            public byte[] SearchName
            {
                get { return _searchname; }
                set
                {
                    if (value == null) { _searchname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _searchname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _searchname, 0, value.Length); }
                }
            }
            public int Type;
            public float Range;
            public float Arc;
            public ulong RegionHandle;
            public byte SearchRegions;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 93;
                    if (SearchName != null) { length += 1 + SearchName.Length; }
                    return length;
                }
            }

            public RequesterBlock() { }
            public RequesterBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    SourceID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                    SearchID = new LLUUID(bytes, i); i += 16;
                    SearchPos = new LLVector3(bytes, i); i += 12;
                    SearchDir = new LLQuaternion(bytes, i, true); i += 12;
                    length = (ushort)bytes[i++];
                    _searchname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _searchname, 0, length); i += length;
                    Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Range = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Arc = BitConverter.ToSingle(bytes, i); i += 4;
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    SearchRegions = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SearchID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SearchPos.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(SearchDir.GetBytes(), 0, bytes, i, 12); i += 12;
                if(SearchName == null) { Console.WriteLine("Warning: SearchName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SearchName.Length;
                Buffer.BlockCopy(SearchName, 0, bytes, i, SearchName.Length); i += SearchName.Length;
                bytes[i++] = (byte)(Type % 256);
                bytes[i++] = (byte)((Type >> 8) % 256);
                bytes[i++] = (byte)((Type >> 16) % 256);
                bytes[i++] = (byte)((Type >> 24) % 256);
                ba = BitConverter.GetBytes(Range);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(Arc);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = SearchRegions;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Requester --");
                output.AppendLine(String.Format("SourceID: {0}", SourceID));
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("SearchID: {0}", SearchID));
                output.AppendLine(String.Format("SearchPos: {0}", SearchPos));
                output.AppendLine(String.Format("SearchDir: {0}", SearchDir));
                Helpers.FieldToString(output, SearchName, "SearchName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("Range: {0}", Range));
                output.AppendLine(String.Format("Arc: {0}", Arc));
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.Append(String.Format("SearchRegions: {0}", SearchRegions));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptSensorRequest; } }
        public RequesterBlock Requester;

        public ScriptSensorRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 247;
            Header.Reliable = true;
            Requester = new RequesterBlock();
        }

        public ScriptSensorRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Requester = new RequesterBlock(bytes, ref i);
        }

        public ScriptSensorRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Requester = new RequesterBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Requester.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Requester.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptSensorRequest ---" + Environment.NewLine;
                output += Requester.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ScriptSensorReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("scriptsensorreply_requester")]
        public class RequesterBlock
        {
            public LLUUID SourceID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public RequesterBlock() { }
            public RequesterBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SourceID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Requester --");
                output.Append(String.Format("SourceID: {0}", SourceID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("scriptsensorreply_senseddata")]
        public class SensedDataBlock
        {
            public LLUUID ObjectID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public LLVector3 Position;
            public LLVector3 Velocity;
            public LLQuaternion Rotation;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public int Type;
            public float Range;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 92;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public SensedDataBlock() { }
            public SensedDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Position = new LLVector3(bytes, i); i += 12;
                    Velocity = new LLVector3(bytes, i); i += 12;
                    Rotation = new LLQuaternion(bytes, i, true); i += 12;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Range = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Velocity.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                bytes[i++] = (byte)(Type % 256);
                bytes[i++] = (byte)((Type >> 8) % 256);
                bytes[i++] = (byte)((Type >> 16) % 256);
                bytes[i++] = (byte)((Type >> 24) % 256);
                ba = BitConverter.GetBytes(Range);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SensedData --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.AppendLine(String.Format("Velocity: {0}", Velocity));
                output.AppendLine(String.Format("Rotation: {0}", Rotation));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Type: {0}", Type));
                output.Append(String.Format("Range: {0}", Range));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ScriptSensorReply; } }
        public RequesterBlock Requester;
        public SensedDataBlock[] SensedData;

        public ScriptSensorReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 248;
            Header.Reliable = true;
            Requester = new RequesterBlock();
            SensedData = new SensedDataBlock[0];
        }

        public ScriptSensorReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            Requester = new RequesterBlock(bytes, ref i);
            int count = (int)bytes[i++];
            SensedData = new SensedDataBlock[count];
            for (int j = 0; j < count; j++)
            { SensedData[j] = new SensedDataBlock(bytes, ref i); }
        }

        public ScriptSensorReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Requester = new RequesterBlock(bytes, ref i);
            int count = (int)bytes[i++];
            SensedData = new SensedDataBlock[count];
            for (int j = 0; j < count; j++)
            { SensedData[j] = new SensedDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += Requester.Length;;
            length++;
            for (int j = 0; j < SensedData.Length; j++) { length += SensedData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Requester.ToBytes(bytes, ref i);
            bytes[i++] = (byte)SensedData.Length;
            for (int j = 0; j < SensedData.Length; j++) { SensedData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ScriptSensorReply ---" + Environment.NewLine;
                output += Requester.ToString() + Environment.NewLine;
            for (int j = 0; j < SensedData.Length; j++)
            {
                output += SensedData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class CompleteAgentMovementPacket : Packet
    {
        /// <exclude/>
        [XmlType("completeagentmovement_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint CircuitCode;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CircuitCode % 256);
                bytes[i++] = (byte)((CircuitCode >> 8) % 256);
                bytes[i++] = (byte)((CircuitCode >> 16) % 256);
                bytes[i++] = (byte)((CircuitCode >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("CircuitCode: {0}", CircuitCode));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CompleteAgentMovement; } }
        public AgentDataBlock AgentData;

        public CompleteAgentMovementPacket()
        {
            Header = new LowHeader();
            Header.ID = 249;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public CompleteAgentMovementPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public CompleteAgentMovementPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CompleteAgentMovement ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentMovementCompletePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentmovementcomplete_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentmovementcomplete_data")]
        public class DataBlock
        {
            public LLVector3 Position;
            public LLVector3 LookAt;
            public ulong RegionHandle;
            public uint Timestamp;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Position = new LLVector3(bytes, i); i += 12;
                    LookAt = new LLVector3(bytes, i); i += 12;
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Timestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(Timestamp % 256);
                bytes[i++] = (byte)((Timestamp >> 8) % 256);
                bytes[i++] = (byte)((Timestamp >> 16) % 256);
                bytes[i++] = (byte)((Timestamp >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("Position: {0}", Position));
                output.AppendLine(String.Format("LookAt: {0}", LookAt));
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.Append(String.Format("Timestamp: {0}", Timestamp));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentMovementComplete; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public AgentMovementCompletePacket()
        {
            Header = new LowHeader();
            Header.ID = 250;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public AgentMovementCompletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public AgentMovementCompletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentMovementComplete ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LogoutRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("logoutrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LogoutRequest; } }
        public AgentDataBlock AgentData;

        public LogoutRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 252;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public LogoutRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public LogoutRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LogoutRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LogoutReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("logoutreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("logoutreply_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LogoutReply; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public LogoutReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 253;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public LogoutReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public LogoutReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LogoutReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ImprovedInstantMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("improvedinstantmessage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("improvedinstantmessage_messageblock")]
        public class MessageBlockBlock
        {
            public bool FromGroup;
            public LLUUID ToAgentID;
            public uint ParentEstateID;
            public LLUUID RegionID;
            public LLVector3 Position;
            public byte Offline;
            public byte Dialog;
            public LLUUID ID;
            public uint Timestamp;
            private byte[] _fromagentname;
            public byte[] FromAgentName
            {
                get { return _fromagentname; }
                set
                {
                    if (value == null) { _fromagentname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _fromagentname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _fromagentname, 0, value.Length); }
                }
            }
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }
            private byte[] _binarybucket;
            public byte[] BinaryBucket
            {
                get { return _binarybucket; }
                set
                {
                    if (value == null) { _binarybucket = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _binarybucket = new byte[value.Length]; Buffer.BlockCopy(value, 0, _binarybucket, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 71;
                    if (FromAgentName != null) { length += 1 + FromAgentName.Length; }
                    if (Message != null) { length += 2 + Message.Length; }
                    if (BinaryBucket != null) { length += 2 + BinaryBucket.Length; }
                    return length;
                }
            }

            public MessageBlockBlock() { }
            public MessageBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    FromGroup = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ToAgentID = new LLUUID(bytes, i); i += 16;
                    ParentEstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RegionID = new LLUUID(bytes, i); i += 16;
                    Position = new LLVector3(bytes, i); i += 12;
                    Offline = (byte)bytes[i++];
                    Dialog = (byte)bytes[i++];
                    ID = new LLUUID(bytes, i); i += 16;
                    Timestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _fromagentname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _fromagentname, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _binarybucket = new byte[length];
                    Buffer.BlockCopy(bytes, i, _binarybucket, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((FromGroup) ? 1 : 0);
                Buffer.BlockCopy(ToAgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ParentEstateID % 256);
                bytes[i++] = (byte)((ParentEstateID >> 8) % 256);
                bytes[i++] = (byte)((ParentEstateID >> 16) % 256);
                bytes[i++] = (byte)((ParentEstateID >> 24) % 256);
                Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = Offline;
                bytes[i++] = Dialog;
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Timestamp % 256);
                bytes[i++] = (byte)((Timestamp >> 8) % 256);
                bytes[i++] = (byte)((Timestamp >> 16) % 256);
                bytes[i++] = (byte)((Timestamp >> 24) % 256);
                if(FromAgentName == null) { Console.WriteLine("Warning: FromAgentName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FromAgentName.Length;
                Buffer.BlockCopy(FromAgentName, 0, bytes, i, FromAgentName.Length); i += FromAgentName.Length;
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Message.Length % 256);
                bytes[i++] = (byte)((Message.Length >> 8) % 256);
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
                if(BinaryBucket == null) { Console.WriteLine("Warning: BinaryBucket is null, in " + this.GetType()); }
                bytes[i++] = (byte)(BinaryBucket.Length % 256);
                bytes[i++] = (byte)((BinaryBucket.Length >> 8) % 256);
                Buffer.BlockCopy(BinaryBucket, 0, bytes, i, BinaryBucket.Length); i += BinaryBucket.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MessageBlock --");
                output.AppendLine(String.Format("FromGroup: {0}", FromGroup));
                output.AppendLine(String.Format("ToAgentID: {0}", ToAgentID));
                output.AppendLine(String.Format("ParentEstateID: {0}", ParentEstateID));
                output.AppendLine(String.Format("RegionID: {0}", RegionID));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.AppendLine(String.Format("Offline: {0}", Offline));
                output.AppendLine(String.Format("Dialog: {0}", Dialog));
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("Timestamp: {0}", Timestamp));
                Helpers.FieldToString(output, FromAgentName, "FromAgentName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Message, "Message");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, BinaryBucket, "BinaryBucket");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ImprovedInstantMessage; } }
        public AgentDataBlock AgentData;
        public MessageBlockBlock MessageBlock;

        public ImprovedInstantMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 254;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MessageBlock = new MessageBlockBlock();
        }

        public ImprovedInstantMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MessageBlock = new MessageBlockBlock(bytes, ref i);
        }

        public ImprovedInstantMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MessageBlock = new MessageBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MessageBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MessageBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ImprovedInstantMessage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MessageBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RetrieveInstantMessagesPacket : Packet
    {
        /// <exclude/>
        [XmlType("retrieveinstantmessages_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RetrieveInstantMessages; } }
        public AgentDataBlock AgentData;

        public RetrieveInstantMessagesPacket()
        {
            Header = new LowHeader();
            Header.ID = 255;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public RetrieveInstantMessagesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public RetrieveInstantMessagesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RetrieveInstantMessages ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class FindAgentPacket : Packet
    {
        /// <exclude/>
        [XmlType("findagent_agentblock")]
        public class AgentBlockBlock
        {
            public LLUUID Hunter;
            public LLUUID Prey;
            public uint SpaceIP;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentBlockBlock() { }
            public AgentBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Hunter = new LLUUID(bytes, i); i += 16;
                    Prey = new LLUUID(bytes, i); i += 16;
                    SpaceIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(Hunter.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Prey.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SpaceIP % 256);
                bytes[i++] = (byte)((SpaceIP >> 8) % 256);
                bytes[i++] = (byte)((SpaceIP >> 16) % 256);
                bytes[i++] = (byte)((SpaceIP >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentBlock --");
                output.AppendLine(String.Format("Hunter: {0}", Hunter));
                output.AppendLine(String.Format("Prey: {0}", Prey));
                output.Append(String.Format("SpaceIP: {0}", SpaceIP));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("findagent_locationblock")]
        public class LocationBlockBlock
        {
            public double GlobalX;
            public double GlobalY;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public LocationBlockBlock() { }
            public LocationBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 8);
                    GlobalX = BitConverter.ToDouble(bytes, i); i += 8;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 8);
                    GlobalY = BitConverter.ToDouble(bytes, i); i += 8;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                ba = BitConverter.GetBytes(GlobalX);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 8); }
                Buffer.BlockCopy(ba, 0, bytes, i, 8); i += 8;
                ba = BitConverter.GetBytes(GlobalY);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 8); }
                Buffer.BlockCopy(ba, 0, bytes, i, 8); i += 8;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- LocationBlock --");
                output.AppendLine(String.Format("GlobalX: {0}", GlobalX));
                output.Append(String.Format("GlobalY: {0}", GlobalY));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.FindAgent; } }
        public AgentBlockBlock AgentBlock;
        public LocationBlockBlock[] LocationBlock;

        public FindAgentPacket()
        {
            Header = new LowHeader();
            Header.ID = 256;
            Header.Reliable = true;
            AgentBlock = new AgentBlockBlock();
            LocationBlock = new LocationBlockBlock[0];
        }

        public FindAgentPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentBlock = new AgentBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            LocationBlock = new LocationBlockBlock[count];
            for (int j = 0; j < count; j++)
            { LocationBlock[j] = new LocationBlockBlock(bytes, ref i); }
        }

        public FindAgentPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentBlock = new AgentBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            LocationBlock = new LocationBlockBlock[count];
            for (int j = 0; j < count; j++)
            { LocationBlock[j] = new LocationBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentBlock.Length;;
            length++;
            for (int j = 0; j < LocationBlock.Length; j++) { length += LocationBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentBlock.ToBytes(bytes, ref i);
            bytes[i++] = (byte)LocationBlock.Length;
            for (int j = 0; j < LocationBlock.Length; j++) { LocationBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- FindAgent ---" + Environment.NewLine;
                output += AgentBlock.ToString() + Environment.NewLine;
            for (int j = 0; j < LocationBlock.Length; j++)
            {
                output += LocationBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RequestGodlikePowersPacket : Packet
    {
        /// <exclude/>
        [XmlType("requestgodlikepowers_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("requestgodlikepowers_requestblock")]
        public class RequestBlockBlock
        {
            public bool Godlike;
            public LLUUID Token;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public RequestBlockBlock() { }
            public RequestBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Token = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((Godlike) ? 1 : 0);
                Buffer.BlockCopy(Token.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestBlock --");
                output.AppendLine(String.Format("Godlike: {0}", Godlike));
                output.Append(String.Format("Token: {0}", Token));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestGodlikePowers; } }
        public AgentDataBlock AgentData;
        public RequestBlockBlock RequestBlock;

        public RequestGodlikePowersPacket()
        {
            Header = new LowHeader();
            Header.ID = 257;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RequestBlock = new RequestBlockBlock();
        }

        public RequestGodlikePowersPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestBlock = new RequestBlockBlock(bytes, ref i);
        }

        public RequestGodlikePowersPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestBlock = new RequestBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RequestBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RequestBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestGodlikePowers ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RequestBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GrantGodlikePowersPacket : Packet
    {
        /// <exclude/>
        [XmlType("grantgodlikepowers_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grantgodlikepowers_grantdata")]
        public class GrantDataBlock
        {
            public byte GodLevel;
            public LLUUID Token;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public GrantDataBlock() { }
            public GrantDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GodLevel = (byte)bytes[i++];
                    Token = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = GodLevel;
                Buffer.BlockCopy(Token.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GrantData --");
                output.AppendLine(String.Format("GodLevel: {0}", GodLevel));
                output.Append(String.Format("Token: {0}", Token));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GrantGodlikePowers; } }
        public AgentDataBlock AgentData;
        public GrantDataBlock GrantData;

        public GrantGodlikePowersPacket()
        {
            Header = new LowHeader();
            Header.ID = 258;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GrantData = new GrantDataBlock();
        }

        public GrantGodlikePowersPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GrantData = new GrantDataBlock(bytes, ref i);
        }

        public GrantGodlikePowersPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GrantData = new GrantDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GrantData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GrantData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GrantGodlikePowers ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GrantData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GodlikeMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("godlikemessage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("godlikemessage_methoddata")]
        public class MethodDataBlock
        {
            private byte[] _method;
            public byte[] Method
            {
                get { return _method; }
                set
                {
                    if (value == null) { _method = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
                }
            }
            public LLUUID Invoice;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Method != null) { length += 1 + Method.Length; }
                    return length;
                }
            }

            public MethodDataBlock() { }
            public MethodDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _method = new byte[length];
                    Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
                    Invoice = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
                bytes[i++] = (byte)Method.Length;
                Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
                Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MethodData --");
                Helpers.FieldToString(output, Method, "Method");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Invoice: {0}", Invoice));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("godlikemessage_paramlist")]
        public class ParamListBlock
        {
            private byte[] _parameter;
            public byte[] Parameter
            {
                get { return _parameter; }
                set
                {
                    if (value == null) { _parameter = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Parameter != null) { length += 1 + Parameter.Length; }
                    return length;
                }
            }

            public ParamListBlock() { }
            public ParamListBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _parameter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
                bytes[i++] = (byte)Parameter.Length;
                Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParamList --");
                Helpers.FieldToString(output, Parameter, "Parameter");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GodlikeMessage; } }
        public AgentDataBlock AgentData;
        public MethodDataBlock MethodData;
        public ParamListBlock[] ParamList;

        public GodlikeMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 259;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MethodData = new MethodDataBlock();
            ParamList = new ParamListBlock[0];
        }

        public GodlikeMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public GodlikeMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MethodData.Length;;
            length++;
            for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MethodData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ParamList.Length;
            for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GodlikeMessage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MethodData.ToString() + Environment.NewLine;
            for (int j = 0; j < ParamList.Length; j++)
            {
                output += ParamList[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class EstateOwnerMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("estateownermessage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("estateownermessage_methoddata")]
        public class MethodDataBlock
        {
            private byte[] _method;
            public byte[] Method
            {
                get { return _method; }
                set
                {
                    if (value == null) { _method = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
                }
            }
            public LLUUID Invoice;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Method != null) { length += 1 + Method.Length; }
                    return length;
                }
            }

            public MethodDataBlock() { }
            public MethodDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _method = new byte[length];
                    Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
                    Invoice = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
                bytes[i++] = (byte)Method.Length;
                Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
                Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MethodData --");
                Helpers.FieldToString(output, Method, "Method");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Invoice: {0}", Invoice));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("estateownermessage_paramlist")]
        public class ParamListBlock
        {
            private byte[] _parameter;
            public byte[] Parameter
            {
                get { return _parameter; }
                set
                {
                    if (value == null) { _parameter = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Parameter != null) { length += 1 + Parameter.Length; }
                    return length;
                }
            }

            public ParamListBlock() { }
            public ParamListBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _parameter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
                bytes[i++] = (byte)Parameter.Length;
                Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParamList --");
                Helpers.FieldToString(output, Parameter, "Parameter");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EstateOwnerMessage; } }
        public AgentDataBlock AgentData;
        public MethodDataBlock MethodData;
        public ParamListBlock[] ParamList;

        public EstateOwnerMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 260;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MethodData = new MethodDataBlock();
            ParamList = new ParamListBlock[0];
        }

        public EstateOwnerMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public EstateOwnerMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MethodData.Length;;
            length++;
            for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MethodData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ParamList.Length;
            for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EstateOwnerMessage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MethodData.ToString() + Environment.NewLine;
            for (int j = 0; j < ParamList.Length; j++)
            {
                output += ParamList[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GenericMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("genericmessage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("genericmessage_methoddata")]
        public class MethodDataBlock
        {
            private byte[] _method;
            public byte[] Method
            {
                get { return _method; }
                set
                {
                    if (value == null) { _method = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
                }
            }
            public LLUUID Invoice;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Method != null) { length += 1 + Method.Length; }
                    return length;
                }
            }

            public MethodDataBlock() { }
            public MethodDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _method = new byte[length];
                    Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
                    Invoice = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
                bytes[i++] = (byte)Method.Length;
                Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
                Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MethodData --");
                Helpers.FieldToString(output, Method, "Method");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Invoice: {0}", Invoice));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("genericmessage_paramlist")]
        public class ParamListBlock
        {
            private byte[] _parameter;
            public byte[] Parameter
            {
                get { return _parameter; }
                set
                {
                    if (value == null) { _parameter = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Parameter != null) { length += 1 + Parameter.Length; }
                    return length;
                }
            }

            public ParamListBlock() { }
            public ParamListBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _parameter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
                bytes[i++] = (byte)Parameter.Length;
                Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParamList --");
                Helpers.FieldToString(output, Parameter, "Parameter");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GenericMessage; } }
        public AgentDataBlock AgentData;
        public MethodDataBlock MethodData;
        public ParamListBlock[] ParamList;

        public GenericMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 261;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MethodData = new MethodDataBlock();
            ParamList = new ParamListBlock[0];
        }

        public GenericMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public GenericMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MethodData.Length;;
            length++;
            for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MethodData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ParamList.Length;
            for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GenericMessage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MethodData.ToString() + Environment.NewLine;
            for (int j = 0; j < ParamList.Length; j++)
            {
                output += ParamList[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MuteListRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("mutelistrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mutelistrequest_mutedata")]
        public class MuteDataBlock
        {
            public uint MuteCRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public MuteDataBlock() { }
            public MuteDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    MuteCRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(MuteCRC % 256);
                bytes[i++] = (byte)((MuteCRC >> 8) % 256);
                bytes[i++] = (byte)((MuteCRC >> 16) % 256);
                bytes[i++] = (byte)((MuteCRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MuteData --");
                output.Append(String.Format("MuteCRC: {0}", MuteCRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MuteListRequest; } }
        public AgentDataBlock AgentData;
        public MuteDataBlock MuteData;

        public MuteListRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 262;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MuteData = new MuteDataBlock();
        }

        public MuteListRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public MuteListRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MuteData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MuteData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MuteListRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MuteData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UpdateMuteListEntryPacket : Packet
    {
        /// <exclude/>
        [XmlType("updatemutelistentry_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updatemutelistentry_mutedata")]
        public class MuteDataBlock
        {
            public LLUUID MuteID;
            private byte[] _mutename;
            public byte[] MuteName
            {
                get { return _mutename; }
                set
                {
                    if (value == null) { _mutename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mutename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mutename, 0, value.Length); }
                }
            }
            public int MuteType;
            public uint MuteFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (MuteName != null) { length += 1 + MuteName.Length; }
                    return length;
                }
            }

            public MuteDataBlock() { }
            public MuteDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    MuteID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _mutename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mutename, 0, length); i += length;
                    MuteType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    MuteFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(MuteID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(MuteName == null) { Console.WriteLine("Warning: MuteName is null, in " + this.GetType()); }
                bytes[i++] = (byte)MuteName.Length;
                Buffer.BlockCopy(MuteName, 0, bytes, i, MuteName.Length); i += MuteName.Length;
                bytes[i++] = (byte)(MuteType % 256);
                bytes[i++] = (byte)((MuteType >> 8) % 256);
                bytes[i++] = (byte)((MuteType >> 16) % 256);
                bytes[i++] = (byte)((MuteType >> 24) % 256);
                bytes[i++] = (byte)(MuteFlags % 256);
                bytes[i++] = (byte)((MuteFlags >> 8) % 256);
                bytes[i++] = (byte)((MuteFlags >> 16) % 256);
                bytes[i++] = (byte)((MuteFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MuteData --");
                output.AppendLine(String.Format("MuteID: {0}", MuteID));
                Helpers.FieldToString(output, MuteName, "MuteName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("MuteType: {0}", MuteType));
                output.Append(String.Format("MuteFlags: {0}", MuteFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateMuteListEntry; } }
        public AgentDataBlock AgentData;
        public MuteDataBlock MuteData;

        public UpdateMuteListEntryPacket()
        {
            Header = new LowHeader();
            Header.ID = 263;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MuteData = new MuteDataBlock();
        }

        public UpdateMuteListEntryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public UpdateMuteListEntryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MuteData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MuteData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateMuteListEntry ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MuteData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RemoveMuteListEntryPacket : Packet
    {
        /// <exclude/>
        [XmlType("removemutelistentry_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("removemutelistentry_mutedata")]
        public class MuteDataBlock
        {
            public LLUUID MuteID;
            private byte[] _mutename;
            public byte[] MuteName
            {
                get { return _mutename; }
                set
                {
                    if (value == null) { _mutename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mutename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mutename, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (MuteName != null) { length += 1 + MuteName.Length; }
                    return length;
                }
            }

            public MuteDataBlock() { }
            public MuteDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    MuteID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _mutename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mutename, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(MuteID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(MuteName == null) { Console.WriteLine("Warning: MuteName is null, in " + this.GetType()); }
                bytes[i++] = (byte)MuteName.Length;
                Buffer.BlockCopy(MuteName, 0, bytes, i, MuteName.Length); i += MuteName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MuteData --");
                output.AppendLine(String.Format("MuteID: {0}", MuteID));
                Helpers.FieldToString(output, MuteName, "MuteName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RemoveMuteListEntry; } }
        public AgentDataBlock AgentData;
        public MuteDataBlock MuteData;

        public RemoveMuteListEntryPacket()
        {
            Header = new LowHeader();
            Header.ID = 264;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MuteData = new MuteDataBlock();
        }

        public RemoveMuteListEntryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public RemoveMuteListEntryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MuteData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MuteData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RemoveMuteListEntry ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MuteData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CopyInventoryFromNotecardPacket : Packet
    {
        /// <exclude/>
        [XmlType("copyinventoryfromnotecard_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("copyinventoryfromnotecard_notecarddata")]
        public class NotecardDataBlock
        {
            public LLUUID NotecardItemID;
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public NotecardDataBlock() { }
            public NotecardDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    NotecardItemID = new LLUUID(bytes, i); i += 16;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(NotecardItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- NotecardData --");
                output.AppendLine(String.Format("NotecardItemID: {0}", NotecardItemID));
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("copyinventoryfromnotecard_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CopyInventoryFromNotecard; } }
        public AgentDataBlock AgentData;
        public NotecardDataBlock NotecardData;
        public InventoryDataBlock[] InventoryData;

        public CopyInventoryFromNotecardPacket()
        {
            Header = new LowHeader();
            Header.ID = 265;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            NotecardData = new NotecardDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public CopyInventoryFromNotecardPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            NotecardData = new NotecardDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public CopyInventoryFromNotecardPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            NotecardData = new NotecardDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += NotecardData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            NotecardData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CopyInventoryFromNotecard ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += NotecardData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UpdateInventoryItemPacket : Packet
    {
        /// <exclude/>
        [XmlType("updateinventoryitem_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updateinventoryitem_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public uint CallbackID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID TransactionID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 140;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CallbackID % 256);
                bytes[i++] = (byte)((CallbackID >> 8) % 256);
                bytes[i++] = (byte)((CallbackID >> 16) % 256);
                bytes[i++] = (byte)((CallbackID >> 24) % 256);
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateInventoryItem; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public UpdateInventoryItemPacket()
        {
            Header = new LowHeader();
            Header.ID = 266;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public UpdateInventoryItemPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public UpdateInventoryItemPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateInventoryItem ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UpdateCreateInventoryItemPacket : Packet
    {
        /// <exclude/>
        [XmlType("updatecreateinventoryitem_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public bool SimApproved;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SimApproved = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((SimApproved) ? 1 : 0);
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SimApproved: {0}", SimApproved));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updatecreateinventoryitem_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public uint CallbackID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID AssetID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 140;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CallbackID % 256);
                bytes[i++] = (byte)((CallbackID >> 8) % 256);
                bytes[i++] = (byte)((CallbackID >> 16) % 256);
                bytes[i++] = (byte)((CallbackID >> 24) % 256);
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateCreateInventoryItem; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public UpdateCreateInventoryItemPacket()
        {
            Header = new LowHeader();
            Header.ID = 267;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public UpdateCreateInventoryItemPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public UpdateCreateInventoryItemPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateCreateInventoryItem ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MoveInventoryItemPacket : Packet
    {
        /// <exclude/>
        [XmlType("moveinventoryitem_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public bool Stamp;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Stamp = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Stamp) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("Stamp: {0}", Stamp));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("moveinventoryitem_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            private byte[] _newname;
            public byte[] NewName
            {
                get { return _newname; }
                set
                {
                    if (value == null) { _newname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _newname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _newname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 32;
                    if (NewName != null) { length += 1 + NewName.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _newname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _newname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(NewName == null) { Console.WriteLine("Warning: NewName is null, in " + this.GetType()); }
                bytes[i++] = (byte)NewName.Length;
                Buffer.BlockCopy(NewName, 0, bytes, i, NewName.Length); i += NewName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                Helpers.FieldToString(output, NewName, "NewName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MoveInventoryItem; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public MoveInventoryItemPacket()
        {
            Header = new LowHeader();
            Header.ID = 268;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public MoveInventoryItemPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public MoveInventoryItemPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MoveInventoryItem ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class CopyInventoryItemPacket : Packet
    {
        /// <exclude/>
        [XmlType("copyinventoryitem_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("copyinventoryitem_inventorydata")]
        public class InventoryDataBlock
        {
            public uint CallbackID;
            public LLUUID OldAgentID;
            public LLUUID OldItemID;
            public LLUUID NewFolderID;
            private byte[] _newname;
            public byte[] NewName
            {
                get { return _newname; }
                set
                {
                    if (value == null) { _newname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _newname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _newname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 52;
                    if (NewName != null) { length += 1 + NewName.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OldAgentID = new LLUUID(bytes, i); i += 16;
                    OldItemID = new LLUUID(bytes, i); i += 16;
                    NewFolderID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _newname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _newname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(CallbackID % 256);
                bytes[i++] = (byte)((CallbackID >> 8) % 256);
                bytes[i++] = (byte)((CallbackID >> 16) % 256);
                bytes[i++] = (byte)((CallbackID >> 24) % 256);
                Buffer.BlockCopy(OldAgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OldItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(NewFolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(NewName == null) { Console.WriteLine("Warning: NewName is null, in " + this.GetType()); }
                bytes[i++] = (byte)NewName.Length;
                Buffer.BlockCopy(NewName, 0, bytes, i, NewName.Length); i += NewName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
                output.AppendLine(String.Format("OldAgentID: {0}", OldAgentID));
                output.AppendLine(String.Format("OldItemID: {0}", OldItemID));
                output.AppendLine(String.Format("NewFolderID: {0}", NewFolderID));
                Helpers.FieldToString(output, NewName, "NewName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CopyInventoryItem; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public CopyInventoryItemPacket()
        {
            Header = new LowHeader();
            Header.ID = 269;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public CopyInventoryItemPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public CopyInventoryItemPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CopyInventoryItem ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RemoveInventoryItemPacket : Packet
    {
        /// <exclude/>
        [XmlType("removeinventoryitem_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("removeinventoryitem_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RemoveInventoryItem; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public RemoveInventoryItemPacket()
        {
            Header = new LowHeader();
            Header.ID = 270;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public RemoveInventoryItemPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public RemoveInventoryItemPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RemoveInventoryItem ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ChangeInventoryItemFlagsPacket : Packet
    {
        /// <exclude/>
        [XmlType("changeinventoryitemflags_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("changeinventoryitemflags_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChangeInventoryItemFlags; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public ChangeInventoryItemFlagsPacket()
        {
            Header = new LowHeader();
            Header.ID = 271;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public ChangeInventoryItemFlagsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public ChangeInventoryItemFlagsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChangeInventoryItemFlags ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class SaveAssetIntoInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("saveassetintoinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("saveassetintoinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID NewAssetID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    NewAssetID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(NewAssetID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("NewAssetID: {0}", NewAssetID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SaveAssetIntoInventory; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock InventoryData;

        public SaveAssetIntoInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 272;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public SaveAssetIntoInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public SaveAssetIntoInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SaveAssetIntoInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateInventoryFolderPacket : Packet
    {
        /// <exclude/>
        [XmlType("createinventoryfolder_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("createinventoryfolder_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;
            public LLUUID ParentID;
            public sbyte Type;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 33;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    ParentID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("ParentID: {0}", ParentID));
                output.AppendLine(String.Format("Type: {0}", Type));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateInventoryFolder; } }
        public AgentDataBlock AgentData;
        public FolderDataBlock FolderData;

        public CreateInventoryFolderPacket()
        {
            Header = new LowHeader();
            Header.ID = 273;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FolderData = new FolderDataBlock();
        }

        public CreateInventoryFolderPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            FolderData = new FolderDataBlock(bytes, ref i);
        }

        public CreateInventoryFolderPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            FolderData = new FolderDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += FolderData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            FolderData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateInventoryFolder ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += FolderData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UpdateInventoryFolderPacket : Packet
    {
        /// <exclude/>
        [XmlType("updateinventoryfolder_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updateinventoryfolder_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;
            public LLUUID ParentID;
            public sbyte Type;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 33;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    ParentID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("ParentID: {0}", ParentID));
                output.AppendLine(String.Format("Type: {0}", Type));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateInventoryFolder; } }
        public AgentDataBlock AgentData;
        public FolderDataBlock[] FolderData;

        public UpdateInventoryFolderPacket()
        {
            Header = new LowHeader();
            Header.ID = 274;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FolderData = new FolderDataBlock[0];
        }

        public UpdateInventoryFolderPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public UpdateInventoryFolderPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateInventoryFolder ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MoveInventoryFolderPacket : Packet
    {
        /// <exclude/>
        [XmlType("moveinventoryfolder_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public bool Stamp;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Stamp = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Stamp) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("Stamp: {0}", Stamp));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("moveinventoryfolder_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID FolderID;
            public LLUUID ParentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    ParentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.Append(String.Format("ParentID: {0}", ParentID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MoveInventoryFolder; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public MoveInventoryFolderPacket()
        {
            Header = new LowHeader();
            Header.ID = 275;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public MoveInventoryFolderPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public MoveInventoryFolderPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MoveInventoryFolder ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RemoveInventoryFolderPacket : Packet
    {
        /// <exclude/>
        [XmlType("removeinventoryfolder_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("removeinventoryfolder_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RemoveInventoryFolder; } }
        public AgentDataBlock AgentData;
        public FolderDataBlock[] FolderData;

        public RemoveInventoryFolderPacket()
        {
            Header = new LowHeader();
            Header.ID = 276;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FolderData = new FolderDataBlock[0];
        }

        public RemoveInventoryFolderPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public RemoveInventoryFolderPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RemoveInventoryFolder ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class FetchInventoryDescendentsPacket : Packet
    {
        /// <exclude/>
        [XmlType("fetchinventorydescendents_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("fetchinventorydescendents_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID FolderID;
            public LLUUID OwnerID;
            public int SortOrder;
            public bool FetchFolders;
            public bool FetchItems;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 38;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    SortOrder = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    FetchFolders = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    FetchItems = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SortOrder % 256);
                bytes[i++] = (byte)((SortOrder >> 8) % 256);
                bytes[i++] = (byte)((SortOrder >> 16) % 256);
                bytes[i++] = (byte)((SortOrder >> 24) % 256);
                bytes[i++] = (byte)((FetchFolders) ? 1 : 0);
                bytes[i++] = (byte)((FetchItems) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("SortOrder: {0}", SortOrder));
                output.AppendLine(String.Format("FetchFolders: {0}", FetchFolders));
                output.Append(String.Format("FetchItems: {0}", FetchItems));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.FetchInventoryDescendents; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock InventoryData;

        public FetchInventoryDescendentsPacket()
        {
            Header = new LowHeader();
            Header.ID = 277;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public FetchInventoryDescendentsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public FetchInventoryDescendentsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- FetchInventoryDescendents ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class InventoryDescendentsPacket : Packet
    {
        /// <exclude/>
        [XmlType("inventorydescendents_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID FolderID;
            public LLUUID OwnerID;
            public int Version;
            public int Descendents;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 56;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    Version = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Descendents = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Version % 256);
                bytes[i++] = (byte)((Version >> 8) % 256);
                bytes[i++] = (byte)((Version >> 16) % 256);
                bytes[i++] = (byte)((Version >> 24) % 256);
                bytes[i++] = (byte)(Descendents % 256);
                bytes[i++] = (byte)((Descendents >> 8) % 256);
                bytes[i++] = (byte)((Descendents >> 16) % 256);
                bytes[i++] = (byte)((Descendents >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("Version: {0}", Version));
                output.Append(String.Format("Descendents: {0}", Descendents));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("inventorydescendents_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;
            public LLUUID ParentID;
            public sbyte Type;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 33;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    ParentID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("ParentID: {0}", ParentID));
                output.AppendLine(String.Format("Type: {0}", Type));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("inventorydescendents_itemdata")]
        public class ItemDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID AssetID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 136;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public ItemDataBlock() { }
            public ItemDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ItemData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.InventoryDescendents; } }
        public AgentDataBlock AgentData;
        public FolderDataBlock[] FolderData;
        public ItemDataBlock[] ItemData;

        public InventoryDescendentsPacket()
        {
            Header = new LowHeader();
            Header.ID = 278;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FolderData = new FolderDataBlock[0];
            ItemData = new ItemDataBlock[0];
        }

        public InventoryDescendentsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            ItemData = new ItemDataBlock[count];
            for (int j = 0; j < count; j++)
            { ItemData[j] = new ItemDataBlock(bytes, ref i); }
        }

        public InventoryDescendentsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            ItemData = new ItemDataBlock[count];
            for (int j = 0; j < count; j++)
            { ItemData[j] = new ItemDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            length++;
            for (int j = 0; j < ItemData.Length; j++) { length += ItemData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)ItemData.Length;
            for (int j = 0; j < ItemData.Length; j++) { ItemData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- InventoryDescendents ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < ItemData.Length; j++)
            {
                output += ItemData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class FetchInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("fetchinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("fetchinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID OwnerID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.FetchInventory; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public FetchInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 279;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public FetchInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public FetchInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- FetchInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class FetchInventoryReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("fetchinventoryreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("fetchinventoryreply_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID AssetID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 136;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.FetchInventoryReply; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock[] InventoryData;

        public FetchInventoryReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 280;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public FetchInventoryReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public FetchInventoryReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- FetchInventoryReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class BulkUpdateInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("bulkupdateinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("bulkupdateinventory_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;
            public LLUUID ParentID;
            public sbyte Type;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 33;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    ParentID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("ParentID: {0}", ParentID));
                output.AppendLine(String.Format("Type: {0}", Type));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("bulkupdateinventory_itemdata")]
        public class ItemDataBlock
        {
            public LLUUID ItemID;
            public uint CallbackID;
            public LLUUID FolderID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID AssetID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 140;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public ItemDataBlock() { }
            public ItemDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CallbackID % 256);
                bytes[i++] = (byte)((CallbackID >> 8) % 256);
                bytes[i++] = (byte)((CallbackID >> 16) % 256);
                bytes[i++] = (byte)((CallbackID >> 24) % 256);
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ItemData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.BulkUpdateInventory; } }
        public AgentDataBlock AgentData;
        public FolderDataBlock[] FolderData;
        public ItemDataBlock[] ItemData;

        public BulkUpdateInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 281;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FolderData = new FolderDataBlock[0];
            ItemData = new ItemDataBlock[0];
        }

        public BulkUpdateInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            ItemData = new ItemDataBlock[count];
            for (int j = 0; j < count; j++)
            { ItemData[j] = new ItemDataBlock(bytes, ref i); }
        }

        public BulkUpdateInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            ItemData = new ItemDataBlock[count];
            for (int j = 0; j < count; j++)
            { ItemData[j] = new ItemDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            length++;
            for (int j = 0; j < ItemData.Length; j++) { length += ItemData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)ItemData.Length;
            for (int j = 0; j < ItemData.Length; j++) { ItemData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- BulkUpdateInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < ItemData.Length; j++)
            {
                output += ItemData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RequestInventoryAssetPacket : Packet
    {
        /// <exclude/>
        [XmlType("requestinventoryasset_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            public LLUUID AgentID;
            public LLUUID OwnerID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 64;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    AgentID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestInventoryAsset; } }
        public QueryDataBlock QueryData;

        public RequestInventoryAssetPacket()
        {
            Header = new LowHeader();
            Header.ID = 282;
            Header.Reliable = true;
            QueryData = new QueryDataBlock();
        }

        public RequestInventoryAssetPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public RequestInventoryAssetPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestInventoryAsset ---" + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class InventoryAssetResponsePacket : Packet
    {
        /// <exclude/>
        [XmlType("inventoryassetresponse_querydata")]
        public class QueryDataBlock
        {
            public LLUUID QueryID;
            public LLUUID AssetID;
            public bool IsReadable;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public QueryDataBlock() { }
            public QueryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    QueryID = new LLUUID(bytes, i); i += 16;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    IsReadable = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsReadable) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- QueryData --");
                output.AppendLine(String.Format("QueryID: {0}", QueryID));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.Append(String.Format("IsReadable: {0}", IsReadable));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.InventoryAssetResponse; } }
        public QueryDataBlock QueryData;

        public InventoryAssetResponsePacket()
        {
            Header = new LowHeader();
            Header.ID = 283;
            Header.Reliable = true;
            QueryData = new QueryDataBlock();
        }

        public InventoryAssetResponsePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public InventoryAssetResponsePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            QueryData = new QueryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += QueryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            QueryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- InventoryAssetResponse ---" + Environment.NewLine;
                output += QueryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RemoveInventoryObjectsPacket : Packet
    {
        /// <exclude/>
        [XmlType("removeinventoryobjects_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("removeinventoryobjects_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("removeinventoryobjects_itemdata")]
        public class ItemDataBlock
        {
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ItemDataBlock() { }
            public ItemDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ItemData --");
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RemoveInventoryObjects; } }
        public AgentDataBlock AgentData;
        public FolderDataBlock[] FolderData;
        public ItemDataBlock[] ItemData;

        public RemoveInventoryObjectsPacket()
        {
            Header = new LowHeader();
            Header.ID = 284;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FolderData = new FolderDataBlock[0];
            ItemData = new ItemDataBlock[0];
        }

        public RemoveInventoryObjectsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            ItemData = new ItemDataBlock[count];
            for (int j = 0; j < count; j++)
            { ItemData[j] = new ItemDataBlock(bytes, ref i); }
        }

        public RemoveInventoryObjectsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            ItemData = new ItemDataBlock[count];
            for (int j = 0; j < count; j++)
            { ItemData[j] = new ItemDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            length++;
            for (int j = 0; j < ItemData.Length; j++) { length += ItemData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)ItemData.Length;
            for (int j = 0; j < ItemData.Length; j++) { ItemData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RemoveInventoryObjects ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < ItemData.Length; j++)
            {
                output += ItemData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class PurgeInventoryDescendentsPacket : Packet
    {
        /// <exclude/>
        [XmlType("purgeinventorydescendents_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("purgeinventorydescendents_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PurgeInventoryDescendents; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock InventoryData;

        public PurgeInventoryDescendentsPacket()
        {
            Header = new LowHeader();
            Header.ID = 285;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public PurgeInventoryDescendentsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public PurgeInventoryDescendentsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PurgeInventoryDescendents ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UpdateTaskInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("updatetaskinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updatetaskinventory_updatedata")]
        public class UpdateDataBlock
        {
            public uint LocalID;
            public byte Key;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 5;
                }
            }

            public UpdateDataBlock() { }
            public UpdateDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Key = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                bytes[i++] = Key;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UpdateData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("Key: {0}", Key));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updatetaskinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID TransactionID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 136;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateTaskInventory; } }
        public AgentDataBlock AgentData;
        public UpdateDataBlock UpdateData;
        public InventoryDataBlock InventoryData;

        public UpdateTaskInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 286;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            UpdateData = new UpdateDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public UpdateTaskInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            UpdateData = new UpdateDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public UpdateTaskInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            UpdateData = new UpdateDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += UpdateData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            UpdateData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateTaskInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += UpdateData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RemoveTaskInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("removetaskinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("removetaskinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public uint LocalID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RemoveTaskInventory; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock InventoryData;

        public RemoveTaskInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 287;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public RemoveTaskInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public RemoveTaskInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RemoveTaskInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MoveTaskInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("movetaskinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("movetaskinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public uint LocalID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MoveTaskInventory; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock InventoryData;

        public MoveTaskInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 288;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public MoveTaskInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public MoveTaskInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MoveTaskInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RequestTaskInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("requesttaskinventory_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("requesttaskinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public uint LocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.Append(String.Format("LocalID: {0}", LocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestTaskInventory; } }
        public AgentDataBlock AgentData;
        public InventoryDataBlock InventoryData;

        public RequestTaskInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 289;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public RequestTaskInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public RequestTaskInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestTaskInventory ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ReplyTaskInventoryPacket : Packet
    {
        /// <exclude/>
        [XmlType("replytaskinventory_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID TaskID;
            public short Serial;
            private byte[] _filename;
            public byte[] Filename
            {
                get { return _filename; }
                set
                {
                    if (value == null) { _filename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 18;
                    if (Filename != null) { length += 1 + Filename.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TaskID = new LLUUID(bytes, i); i += 16;
                    Serial = (short)(bytes[i++] + (bytes[i++] << 8));
                    length = (ushort)bytes[i++];
                    _filename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Serial % 256);
                bytes[i++] = (byte)((Serial >> 8) % 256);
                if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
                bytes[i++] = (byte)Filename.Length;
                Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("TaskID: {0}", TaskID));
                output.AppendLine(String.Format("Serial: {0}", Serial));
                Helpers.FieldToString(output, Filename, "Filename");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ReplyTaskInventory; } }
        public InventoryDataBlock InventoryData;

        public ReplyTaskInventoryPacket()
        {
            Header = new LowHeader();
            Header.ID = 290;
            Header.Reliable = true;
            InventoryData = new InventoryDataBlock();
        }

        public ReplyTaskInventoryPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public ReplyTaskInventoryPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ReplyTaskInventory ---" + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DeRezObjectPacket : Packet
    {
        /// <exclude/>
        [XmlType("derezobject_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("derezobject_agentblock")]
        public class AgentBlockBlock
        {
            public LLUUID GroupID;
            public byte Destination;
            public LLUUID DestinationID;
            public LLUUID TransactionID;
            public byte PacketCount;
            public byte PacketNumber;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 51;
                }
            }

            public AgentBlockBlock() { }
            public AgentBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Destination = (byte)bytes[i++];
                    DestinationID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    PacketCount = (byte)bytes[i++];
                    PacketNumber = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = Destination;
                Buffer.BlockCopy(DestinationID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = PacketCount;
                bytes[i++] = PacketNumber;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentBlock --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("Destination: {0}", Destination));
                output.AppendLine(String.Format("DestinationID: {0}", DestinationID));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("PacketCount: {0}", PacketCount));
                output.Append(String.Format("PacketNumber: {0}", PacketNumber));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("derezobject_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DeRezObject; } }
        public AgentDataBlock AgentData;
        public AgentBlockBlock AgentBlock;
        public ObjectDataBlock[] ObjectData;

        public DeRezObjectPacket()
        {
            Header = new LowHeader();
            Header.ID = 291;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            AgentBlock = new AgentBlockBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public DeRezObjectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            AgentBlock = new AgentBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public DeRezObjectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            AgentBlock = new AgentBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += AgentBlock.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            AgentBlock.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DeRezObject ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += AgentBlock.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DeRezAckPacket : Packet
    {
        /// <exclude/>
        [XmlType("derezack_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;
            public bool Success;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Success) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.Append(String.Format("Success: {0}", Success));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DeRezAck; } }
        public TransactionDataBlock TransactionData;

        public DeRezAckPacket()
        {
            Header = new LowHeader();
            Header.ID = 292;
            Header.Reliable = true;
            TransactionData = new TransactionDataBlock();
        }

        public DeRezAckPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TransactionData = new TransactionDataBlock(bytes, ref i);
        }

        public DeRezAckPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TransactionData = new TransactionDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TransactionData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DeRezAck ---" + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RezObjectPacket : Packet
    {
        /// <exclude/>
        [XmlType("rezobject_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezobject_rezdata")]
        public class RezDataBlock
        {
            public LLUUID FromTaskID;
            public byte BypassRaycast;
            public LLVector3 RayStart;
            public LLVector3 RayEnd;
            public LLUUID RayTargetID;
            public bool RayEndIsIntersection;
            public bool RezSelected;
            public bool RemoveItem;
            public uint ItemFlags;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 76;
                }
            }

            public RezDataBlock() { }
            public RezDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FromTaskID = new LLUUID(bytes, i); i += 16;
                    BypassRaycast = (byte)bytes[i++];
                    RayStart = new LLVector3(bytes, i); i += 12;
                    RayEnd = new LLVector3(bytes, i); i += 12;
                    RayTargetID = new LLUUID(bytes, i); i += 16;
                    RayEndIsIntersection = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RezSelected = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RemoveItem = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FromTaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = BypassRaycast;
                Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((RayEndIsIntersection) ? 1 : 0);
                bytes[i++] = (byte)((RezSelected) ? 1 : 0);
                bytes[i++] = (byte)((RemoveItem) ? 1 : 0);
                bytes[i++] = (byte)(ItemFlags % 256);
                bytes[i++] = (byte)((ItemFlags >> 8) % 256);
                bytes[i++] = (byte)((ItemFlags >> 16) % 256);
                bytes[i++] = (byte)((ItemFlags >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RezData --");
                output.AppendLine(String.Format("FromTaskID: {0}", FromTaskID));
                output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
                output.AppendLine(String.Format("RayStart: {0}", RayStart));
                output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
                output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
                output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
                output.AppendLine(String.Format("RezSelected: {0}", RezSelected));
                output.AppendLine(String.Format("RemoveItem: {0}", RemoveItem));
                output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.Append(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezobject_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID TransactionID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 136;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RezObject; } }
        public AgentDataBlock AgentData;
        public RezDataBlock RezData;
        public InventoryDataBlock InventoryData;

        public RezObjectPacket()
        {
            Header = new LowHeader();
            Header.ID = 293;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RezData = new RezDataBlock();
            InventoryData = new InventoryDataBlock();
        }

        public RezObjectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RezData = new RezDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public RezObjectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RezData = new RezDataBlock(bytes, ref i);
            InventoryData = new InventoryDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RezData.Length;            length += InventoryData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RezData.ToBytes(bytes, ref i);
            InventoryData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RezObject ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RezData.ToString() + Environment.NewLine;
                output += InventoryData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RezObjectFromNotecardPacket : Packet
    {
        /// <exclude/>
        [XmlType("rezobjectfromnotecard_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezobjectfromnotecard_rezdata")]
        public class RezDataBlock
        {
            public LLUUID FromTaskID;
            public byte BypassRaycast;
            public LLVector3 RayStart;
            public LLVector3 RayEnd;
            public LLUUID RayTargetID;
            public bool RayEndIsIntersection;
            public bool RezSelected;
            public bool RemoveItem;
            public uint ItemFlags;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 76;
                }
            }

            public RezDataBlock() { }
            public RezDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FromTaskID = new LLUUID(bytes, i); i += 16;
                    BypassRaycast = (byte)bytes[i++];
                    RayStart = new LLVector3(bytes, i); i += 12;
                    RayEnd = new LLVector3(bytes, i); i += 12;
                    RayTargetID = new LLUUID(bytes, i); i += 16;
                    RayEndIsIntersection = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RezSelected = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RemoveItem = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FromTaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = BypassRaycast;
                Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((RayEndIsIntersection) ? 1 : 0);
                bytes[i++] = (byte)((RezSelected) ? 1 : 0);
                bytes[i++] = (byte)((RemoveItem) ? 1 : 0);
                bytes[i++] = (byte)(ItemFlags % 256);
                bytes[i++] = (byte)((ItemFlags >> 8) % 256);
                bytes[i++] = (byte)((ItemFlags >> 16) % 256);
                bytes[i++] = (byte)((ItemFlags >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RezData --");
                output.AppendLine(String.Format("FromTaskID: {0}", FromTaskID));
                output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
                output.AppendLine(String.Format("RayStart: {0}", RayStart));
                output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
                output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
                output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
                output.AppendLine(String.Format("RezSelected: {0}", RezSelected));
                output.AppendLine(String.Format("RemoveItem: {0}", RemoveItem));
                output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.Append(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezobjectfromnotecard_notecarddata")]
        public class NotecardDataBlock
        {
            public LLUUID NotecardItemID;
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public NotecardDataBlock() { }
            public NotecardDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    NotecardItemID = new LLUUID(bytes, i); i += 16;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(NotecardItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- NotecardData --");
                output.AppendLine(String.Format("NotecardItemID: {0}", NotecardItemID));
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezobjectfromnotecard_inventorydata")]
        public class InventoryDataBlock
        {
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public InventoryDataBlock() { }
            public InventoryDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryData --");
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RezObjectFromNotecard; } }
        public AgentDataBlock AgentData;
        public RezDataBlock RezData;
        public NotecardDataBlock NotecardData;
        public InventoryDataBlock[] InventoryData;

        public RezObjectFromNotecardPacket()
        {
            Header = new LowHeader();
            Header.ID = 294;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RezData = new RezDataBlock();
            NotecardData = new NotecardDataBlock();
            InventoryData = new InventoryDataBlock[0];
        }

        public RezObjectFromNotecardPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RezData = new RezDataBlock(bytes, ref i);
            NotecardData = new NotecardDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public RezObjectFromNotecardPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RezData = new RezDataBlock(bytes, ref i);
            NotecardData = new NotecardDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InventoryData = new InventoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { InventoryData[j] = new InventoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RezData.Length;            length += NotecardData.Length;;
            length++;
            for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RezData.ToBytes(bytes, ref i);
            NotecardData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InventoryData.Length;
            for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RezObjectFromNotecard ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RezData.ToString() + Environment.NewLine;
                output += NotecardData.ToString() + Environment.NewLine;
            for (int j = 0; j < InventoryData.Length; j++)
            {
                output += InventoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AcceptFriendshipPacket : Packet
    {
        /// <exclude/>
        [XmlType("acceptfriendship_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("acceptfriendship_transactionblock")]
        public class TransactionBlockBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionBlockBlock() { }
            public TransactionBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionBlock --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("acceptfriendship_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AcceptFriendship; } }
        public AgentDataBlock AgentData;
        public TransactionBlockBlock TransactionBlock;
        public FolderDataBlock[] FolderData;

        public AcceptFriendshipPacket()
        {
            Header = new LowHeader();
            Header.ID = 297;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionBlock = new TransactionBlockBlock();
            FolderData = new FolderDataBlock[0];
        }

        public AcceptFriendshipPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public AcceptFriendshipPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionBlock.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionBlock.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AcceptFriendship ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionBlock.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DeclineFriendshipPacket : Packet
    {
        /// <exclude/>
        [XmlType("declinefriendship_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("declinefriendship_transactionblock")]
        public class TransactionBlockBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionBlockBlock() { }
            public TransactionBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionBlock --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DeclineFriendship; } }
        public AgentDataBlock AgentData;
        public TransactionBlockBlock TransactionBlock;

        public DeclineFriendshipPacket()
        {
            Header = new LowHeader();
            Header.ID = 298;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionBlock = new TransactionBlockBlock();
        }

        public DeclineFriendshipPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
        }

        public DeclineFriendshipPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DeclineFriendship ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class FormFriendshipPacket : Packet
    {
        /// <exclude/>
        [XmlType("formfriendship_agentblock")]
        public class AgentBlockBlock
        {
            public LLUUID SourceID;
            public LLUUID DestID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentBlockBlock() { }
            public AgentBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SourceID = new LLUUID(bytes, i); i += 16;
                    DestID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(DestID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentBlock --");
                output.AppendLine(String.Format("SourceID: {0}", SourceID));
                output.Append(String.Format("DestID: {0}", DestID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.FormFriendship; } }
        public AgentBlockBlock AgentBlock;

        public FormFriendshipPacket()
        {
            Header = new LowHeader();
            Header.ID = 299;
            Header.Reliable = true;
            AgentBlock = new AgentBlockBlock();
        }

        public FormFriendshipPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentBlock = new AgentBlockBlock(bytes, ref i);
        }

        public FormFriendshipPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentBlock = new AgentBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- FormFriendship ---" + Environment.NewLine;
                output += AgentBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class TerminateFriendshipPacket : Packet
    {
        /// <exclude/>
        [XmlType("terminatefriendship_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("terminatefriendship_exblock")]
        public class ExBlockBlock
        {
            public LLUUID OtherID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ExBlockBlock() { }
            public ExBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OtherID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OtherID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ExBlock --");
                output.Append(String.Format("OtherID: {0}", OtherID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TerminateFriendship; } }
        public AgentDataBlock AgentData;
        public ExBlockBlock ExBlock;

        public TerminateFriendshipPacket()
        {
            Header = new LowHeader();
            Header.ID = 300;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ExBlock = new ExBlockBlock();
        }

        public TerminateFriendshipPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ExBlock = new ExBlockBlock(bytes, ref i);
        }

        public TerminateFriendshipPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ExBlock = new ExBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ExBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ExBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TerminateFriendship ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ExBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class OfferCallingCardPacket : Packet
    {
        /// <exclude/>
        [XmlType("offercallingcard_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("offercallingcard_agentblock")]
        public class AgentBlockBlock
        {
            public LLUUID DestID;
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentBlockBlock() { }
            public AgentBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    DestID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(DestID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentBlock --");
                output.AppendLine(String.Format("DestID: {0}", DestID));
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.OfferCallingCard; } }
        public AgentDataBlock AgentData;
        public AgentBlockBlock AgentBlock;

        public OfferCallingCardPacket()
        {
            Header = new LowHeader();
            Header.ID = 301;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            AgentBlock = new AgentBlockBlock();
        }

        public OfferCallingCardPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            AgentBlock = new AgentBlockBlock(bytes, ref i);
        }

        public OfferCallingCardPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            AgentBlock = new AgentBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += AgentBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            AgentBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- OfferCallingCard ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += AgentBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AcceptCallingCardPacket : Packet
    {
        /// <exclude/>
        [XmlType("acceptcallingcard_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("acceptcallingcard_transactionblock")]
        public class TransactionBlockBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionBlockBlock() { }
            public TransactionBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionBlock --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("acceptcallingcard_folderdata")]
        public class FolderDataBlock
        {
            public LLUUID FolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public FolderDataBlock() { }
            public FolderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FolderData --");
                output.Append(String.Format("FolderID: {0}", FolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AcceptCallingCard; } }
        public AgentDataBlock AgentData;
        public TransactionBlockBlock TransactionBlock;
        public FolderDataBlock[] FolderData;

        public AcceptCallingCardPacket()
        {
            Header = new LowHeader();
            Header.ID = 302;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionBlock = new TransactionBlockBlock();
            FolderData = new FolderDataBlock[0];
        }

        public AcceptCallingCardPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public AcceptCallingCardPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
            int count = (int)bytes[i++];
            FolderData = new FolderDataBlock[count];
            for (int j = 0; j < count; j++)
            { FolderData[j] = new FolderDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionBlock.Length;;
            length++;
            for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionBlock.ToBytes(bytes, ref i);
            bytes[i++] = (byte)FolderData.Length;
            for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AcceptCallingCard ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionBlock.ToString() + Environment.NewLine;
            for (int j = 0; j < FolderData.Length; j++)
            {
                output += FolderData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DeclineCallingCardPacket : Packet
    {
        /// <exclude/>
        [XmlType("declinecallingcard_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("declinecallingcard_transactionblock")]
        public class TransactionBlockBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionBlockBlock() { }
            public TransactionBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionBlock --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DeclineCallingCard; } }
        public AgentDataBlock AgentData;
        public TransactionBlockBlock TransactionBlock;

        public DeclineCallingCardPacket()
        {
            Header = new LowHeader();
            Header.ID = 303;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionBlock = new TransactionBlockBlock();
        }

        public DeclineCallingCardPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
        }

        public DeclineCallingCardPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionBlock = new TransactionBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DeclineCallingCard ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RezScriptPacket : Packet
    {
        /// <exclude/>
        [XmlType("rezscript_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezscript_updateblock")]
        public class UpdateBlockBlock
        {
            public uint ObjectLocalID;
            public bool Enabled;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 5;
                }
            }

            public UpdateBlockBlock() { }
            public UpdateBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Enabled = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = (byte)((Enabled) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UpdateBlock --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("Enabled: {0}", Enabled));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezscript_inventoryblock")]
        public class InventoryBlockBlock
        {
            public LLUUID ItemID;
            public LLUUID FolderID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public bool GroupOwned;
            public LLUUID TransactionID;
            public sbyte Type;
            public sbyte InvType;
            public uint Flags;
            public byte SaleType;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int CreationDate;
            public uint CRC;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 136;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryBlockBlock() { }
            public InventoryBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryBlock --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.Append(String.Format("CRC: {0}", CRC));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RezScript; } }
        public AgentDataBlock AgentData;
        public UpdateBlockBlock UpdateBlock;
        public InventoryBlockBlock InventoryBlock;

        public RezScriptPacket()
        {
            Header = new LowHeader();
            Header.ID = 304;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            UpdateBlock = new UpdateBlockBlock();
            InventoryBlock = new InventoryBlockBlock();
        }

        public RezScriptPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            UpdateBlock = new UpdateBlockBlock(bytes, ref i);
            InventoryBlock = new InventoryBlockBlock(bytes, ref i);
        }

        public RezScriptPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            UpdateBlock = new UpdateBlockBlock(bytes, ref i);
            InventoryBlock = new InventoryBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += UpdateBlock.Length;            length += InventoryBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            UpdateBlock.ToBytes(bytes, ref i);
            InventoryBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RezScript ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += UpdateBlock.ToString() + Environment.NewLine;
                output += InventoryBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateInventoryItemPacket : Packet
    {
        /// <exclude/>
        [XmlType("createinventoryitem_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("createinventoryitem_inventoryblock")]
        public class InventoryBlockBlock
        {
            public uint CallbackID;
            public LLUUID FolderID;
            public LLUUID TransactionID;
            public uint NextOwnerMask;
            public sbyte Type;
            public sbyte InvType;
            public byte WearableType;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 43;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public InventoryBlockBlock() { }
            public InventoryBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    FolderID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Type = (sbyte)bytes[i++];
                    InvType = (sbyte)bytes[i++];
                    WearableType = (byte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(CallbackID % 256);
                bytes[i++] = (byte)((CallbackID >> 8) % 256);
                bytes[i++] = (byte)((CallbackID >> 16) % 256);
                bytes[i++] = (byte)((CallbackID >> 24) % 256);
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)InvType;
                bytes[i++] = WearableType;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryBlock --");
                output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("InvType: {0}", InvType));
                output.AppendLine(String.Format("WearableType: {0}", WearableType));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateInventoryItem; } }
        public AgentDataBlock AgentData;
        public InventoryBlockBlock InventoryBlock;

        public CreateInventoryItemPacket()
        {
            Header = new LowHeader();
            Header.ID = 305;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            InventoryBlock = new InventoryBlockBlock();
        }

        public CreateInventoryItemPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryBlock = new InventoryBlockBlock(bytes, ref i);
        }

        public CreateInventoryItemPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            InventoryBlock = new InventoryBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += InventoryBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            InventoryBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateInventoryItem ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += InventoryBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateLandmarkForEventPacket : Packet
    {
        /// <exclude/>
        [XmlType("createlandmarkforevent_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("createlandmarkforevent_eventdata")]
        public class EventDataBlock
        {
            public uint EventID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public EventDataBlock() { }
            public EventDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(EventID % 256);
                bytes[i++] = (byte)((EventID >> 8) % 256);
                bytes[i++] = (byte)((EventID >> 16) % 256);
                bytes[i++] = (byte)((EventID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EventData --");
                output.Append(String.Format("EventID: {0}", EventID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("createlandmarkforevent_inventoryblock")]
        public class InventoryBlockBlock
        {
            public LLUUID FolderID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public InventoryBlockBlock() { }
            public InventoryBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    FolderID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InventoryBlock --");
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateLandmarkForEvent; } }
        public AgentDataBlock AgentData;
        public EventDataBlock EventData;
        public InventoryBlockBlock InventoryBlock;

        public CreateLandmarkForEventPacket()
        {
            Header = new LowHeader();
            Header.ID = 306;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            EventData = new EventDataBlock();
            InventoryBlock = new InventoryBlockBlock();
        }

        public CreateLandmarkForEventPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
            InventoryBlock = new InventoryBlockBlock(bytes, ref i);
        }

        public CreateLandmarkForEventPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            EventData = new EventDataBlock(bytes, ref i);
            InventoryBlock = new InventoryBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += EventData.Length;            length += InventoryBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            EventData.ToBytes(bytes, ref i);
            InventoryBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateLandmarkForEvent ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += EventData.ToString() + Environment.NewLine;
                output += InventoryBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RegionHandleRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("regionhandlerequest_requestblock")]
        public class RequestBlockBlock
        {
            public LLUUID RegionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public RequestBlockBlock() { }
            public RequestBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestBlock --");
                output.Append(String.Format("RegionID: {0}", RegionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RegionHandleRequest; } }
        public RequestBlockBlock RequestBlock;

        public RegionHandleRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 309;
            Header.Reliable = true;
            RequestBlock = new RequestBlockBlock();
        }

        public RegionHandleRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            RequestBlock = new RequestBlockBlock(bytes, ref i);
        }

        public RegionHandleRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RequestBlock = new RequestBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += RequestBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RequestBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RegionHandleRequest ---" + Environment.NewLine;
                output += RequestBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RegionIDAndHandleReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("regionidandhandlereply_replyblock")]
        public class ReplyBlockBlock
        {
            public LLUUID RegionID;
            public ulong RegionHandle;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public ReplyBlockBlock() { }
            public ReplyBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionID = new LLUUID(bytes, i); i += 16;
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ReplyBlock --");
                output.AppendLine(String.Format("RegionID: {0}", RegionID));
                output.Append(String.Format("RegionHandle: {0}", RegionHandle));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RegionIDAndHandleReply; } }
        public ReplyBlockBlock ReplyBlock;

        public RegionIDAndHandleReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 310;
            Header.Reliable = true;
            ReplyBlock = new ReplyBlockBlock();
        }

        public RegionIDAndHandleReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ReplyBlock = new ReplyBlockBlock(bytes, ref i);
        }

        public RegionIDAndHandleReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ReplyBlock = new ReplyBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ReplyBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ReplyBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RegionIDAndHandleReply ---" + Environment.NewLine;
                output += ReplyBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MoneyTransferRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("moneytransferrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("moneytransferrequest_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID SourceID;
            public LLUUID DestID;
            public byte Flags;
            public int Amount;
            public byte AggregatePermNextOwner;
            public byte AggregatePermInventory;
            public int TransactionType;
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 43;
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    SourceID = new LLUUID(bytes, i); i += 16;
                    DestID = new LLUUID(bytes, i); i += 16;
                    Flags = (byte)bytes[i++];
                    Amount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AggregatePermNextOwner = (byte)bytes[i++];
                    AggregatePermInventory = (byte)bytes[i++];
                    TransactionType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(DestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = Flags;
                bytes[i++] = (byte)(Amount % 256);
                bytes[i++] = (byte)((Amount >> 8) % 256);
                bytes[i++] = (byte)((Amount >> 16) % 256);
                bytes[i++] = (byte)((Amount >> 24) % 256);
                bytes[i++] = AggregatePermNextOwner;
                bytes[i++] = AggregatePermInventory;
                bytes[i++] = (byte)(TransactionType % 256);
                bytes[i++] = (byte)((TransactionType >> 8) % 256);
                bytes[i++] = (byte)((TransactionType >> 16) % 256);
                bytes[i++] = (byte)((TransactionType >> 24) % 256);
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("SourceID: {0}", SourceID));
                output.AppendLine(String.Format("DestID: {0}", DestID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("Amount: {0}", Amount));
                output.AppendLine(String.Format("AggregatePermNextOwner: {0}", AggregatePermNextOwner));
                output.AppendLine(String.Format("AggregatePermInventory: {0}", AggregatePermInventory));
                output.AppendLine(String.Format("TransactionType: {0}", TransactionType));
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MoneyTransferRequest; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;

        public MoneyTransferRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 311;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
        }

        public MoneyTransferRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public MoneyTransferRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MoneyTransferRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MoneyBalanceRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("moneybalancerequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("moneybalancerequest_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MoneyBalanceRequest; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;

        public MoneyBalanceRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 313;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
        }

        public MoneyBalanceRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public MoneyBalanceRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MoneyBalanceRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MoneyBalanceReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("moneybalancereply_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID AgentID;
            public LLUUID TransactionID;
            public bool TransactionSuccess;
            public int MoneyBalance;
            public int SquareMetersCredit;
            public int SquareMetersCommitted;
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 45;
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    TransactionSuccess = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MoneyBalance = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SquareMetersCredit = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SquareMetersCommitted = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((TransactionSuccess) ? 1 : 0);
                bytes[i++] = (byte)(MoneyBalance % 256);
                bytes[i++] = (byte)((MoneyBalance >> 8) % 256);
                bytes[i++] = (byte)((MoneyBalance >> 16) % 256);
                bytes[i++] = (byte)((MoneyBalance >> 24) % 256);
                bytes[i++] = (byte)(SquareMetersCredit % 256);
                bytes[i++] = (byte)((SquareMetersCredit >> 8) % 256);
                bytes[i++] = (byte)((SquareMetersCredit >> 16) % 256);
                bytes[i++] = (byte)((SquareMetersCredit >> 24) % 256);
                bytes[i++] = (byte)(SquareMetersCommitted % 256);
                bytes[i++] = (byte)((SquareMetersCommitted >> 8) % 256);
                bytes[i++] = (byte)((SquareMetersCommitted >> 16) % 256);
                bytes[i++] = (byte)((SquareMetersCommitted >> 24) % 256);
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("TransactionSuccess: {0}", TransactionSuccess));
                output.AppendLine(String.Format("MoneyBalance: {0}", MoneyBalance));
                output.AppendLine(String.Format("SquareMetersCredit: {0}", SquareMetersCredit));
                output.AppendLine(String.Format("SquareMetersCommitted: {0}", SquareMetersCommitted));
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MoneyBalanceReply; } }
        public MoneyDataBlock MoneyData;

        public MoneyBalanceReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 314;
            Header.Reliable = true;
            MoneyData = new MoneyDataBlock();
        }

        public MoneyBalanceReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public MoneyBalanceReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MoneyBalanceReply ---" + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RoutedMoneyBalanceReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("routedmoneybalancereply_targetblock")]
        public class TargetBlockBlock
        {
            public uint TargetIP;
            public ushort TargetPort;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 6;
                }
            }

            public TargetBlockBlock() { }
            public TargetBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TargetPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(TargetIP % 256);
                bytes[i++] = (byte)((TargetIP >> 8) % 256);
                bytes[i++] = (byte)((TargetIP >> 16) % 256);
                bytes[i++] = (byte)((TargetIP >> 24) % 256);
                bytes[i++] = (byte)((TargetPort >> 8) % 256);
                bytes[i++] = (byte)(TargetPort % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TargetBlock --");
                output.AppendLine(String.Format("TargetIP: {0}", TargetIP));
                output.Append(String.Format("TargetPort: {0}", TargetPort));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("routedmoneybalancereply_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID AgentID;
            public LLUUID TransactionID;
            public bool TransactionSuccess;
            public int MoneyBalance;
            public int SquareMetersCredit;
            public int SquareMetersCommitted;
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 45;
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    TransactionSuccess = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MoneyBalance = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SquareMetersCredit = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SquareMetersCommitted = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((TransactionSuccess) ? 1 : 0);
                bytes[i++] = (byte)(MoneyBalance % 256);
                bytes[i++] = (byte)((MoneyBalance >> 8) % 256);
                bytes[i++] = (byte)((MoneyBalance >> 16) % 256);
                bytes[i++] = (byte)((MoneyBalance >> 24) % 256);
                bytes[i++] = (byte)(SquareMetersCredit % 256);
                bytes[i++] = (byte)((SquareMetersCredit >> 8) % 256);
                bytes[i++] = (byte)((SquareMetersCredit >> 16) % 256);
                bytes[i++] = (byte)((SquareMetersCredit >> 24) % 256);
                bytes[i++] = (byte)(SquareMetersCommitted % 256);
                bytes[i++] = (byte)((SquareMetersCommitted >> 8) % 256);
                bytes[i++] = (byte)((SquareMetersCommitted >> 16) % 256);
                bytes[i++] = (byte)((SquareMetersCommitted >> 24) % 256);
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("TransactionSuccess: {0}", TransactionSuccess));
                output.AppendLine(String.Format("MoneyBalance: {0}", MoneyBalance));
                output.AppendLine(String.Format("SquareMetersCredit: {0}", SquareMetersCredit));
                output.AppendLine(String.Format("SquareMetersCommitted: {0}", SquareMetersCommitted));
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RoutedMoneyBalanceReply; } }
        public TargetBlockBlock TargetBlock;
        public MoneyDataBlock MoneyData;

        public RoutedMoneyBalanceReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 315;
            Header.Reliable = true;
            TargetBlock = new TargetBlockBlock();
            MoneyData = new MoneyDataBlock();
        }

        public RoutedMoneyBalanceReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            TargetBlock = new TargetBlockBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public RoutedMoneyBalanceReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TargetBlock = new TargetBlockBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += TargetBlock.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TargetBlock.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RoutedMoneyBalanceReply ---" + Environment.NewLine;
                output += TargetBlock.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ActivateGesturesPacket : Packet
    {
        /// <exclude/>
        [XmlType("activategestures_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("activategestures_data")]
        public class DataBlock
        {
            public LLUUID ItemID;
            public LLUUID AssetID;
            public uint GestureFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    GestureFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(GestureFlags % 256);
                bytes[i++] = (byte)((GestureFlags >> 8) % 256);
                bytes[i++] = (byte)((GestureFlags >> 16) % 256);
                bytes[i++] = (byte)((GestureFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.Append(String.Format("GestureFlags: {0}", GestureFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ActivateGestures; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public ActivateGesturesPacket()
        {
            Header = new LowHeader();
            Header.ID = 316;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public ActivateGesturesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public ActivateGesturesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ActivateGestures ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DeactivateGesturesPacket : Packet
    {
        /// <exclude/>
        [XmlType("deactivategestures_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("deactivategestures_data")]
        public class DataBlock
        {
            public LLUUID ItemID;
            public uint GestureFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    GestureFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(GestureFlags % 256);
                bytes[i++] = (byte)((GestureFlags >> 8) % 256);
                bytes[i++] = (byte)((GestureFlags >> 16) % 256);
                bytes[i++] = (byte)((GestureFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("GestureFlags: {0}", GestureFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DeactivateGestures; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public DeactivateGesturesPacket()
        {
            Header = new LowHeader();
            Header.ID = 317;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public DeactivateGesturesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public DeactivateGesturesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DeactivateGestures ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MuteListUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("mutelistupdate_mutedata")]
        public class MuteDataBlock
        {
            public LLUUID AgentID;
            private byte[] _filename;
            public byte[] Filename
            {
                get { return _filename; }
                set
                {
                    if (value == null) { _filename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 16;
                    if (Filename != null) { length += 1 + Filename.Length; }
                    return length;
                }
            }

            public MuteDataBlock() { }
            public MuteDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _filename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
                bytes[i++] = (byte)Filename.Length;
                Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MuteData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                Helpers.FieldToString(output, Filename, "Filename");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MuteListUpdate; } }
        public MuteDataBlock MuteData;

        public MuteListUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 318;
            Header.Reliable = true;
            MuteData = new MuteDataBlock();
        }

        public MuteListUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public MuteListUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            MuteData = new MuteDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += MuteData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            MuteData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MuteListUpdate ---" + Environment.NewLine;
                output += MuteData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UseCachedMuteListPacket : Packet
    {
        /// <exclude/>
        [XmlType("usecachedmutelist_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UseCachedMuteList; } }
        public AgentDataBlock AgentData;

        public UseCachedMuteListPacket()
        {
            Header = new LowHeader();
            Header.ID = 319;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public UseCachedMuteListPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public UseCachedMuteListPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UseCachedMuteList ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GrantUserRightsPacket : Packet
    {
        /// <exclude/>
        [XmlType("grantuserrights_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grantuserrights_rights")]
        public class RightsBlock
        {
            public LLUUID AgentRelated;
            public int RelatedRights;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public RightsBlock() { }
            public RightsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentRelated = new LLUUID(bytes, i); i += 16;
                    RelatedRights = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentRelated.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(RelatedRights % 256);
                bytes[i++] = (byte)((RelatedRights >> 8) % 256);
                bytes[i++] = (byte)((RelatedRights >> 16) % 256);
                bytes[i++] = (byte)((RelatedRights >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Rights --");
                output.AppendLine(String.Format("AgentRelated: {0}", AgentRelated));
                output.Append(String.Format("RelatedRights: {0}", RelatedRights));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GrantUserRights; } }
        public AgentDataBlock AgentData;
        public RightsBlock[] Rights;

        public GrantUserRightsPacket()
        {
            Header = new LowHeader();
            Header.ID = 320;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Rights = new RightsBlock[0];
        }

        public GrantUserRightsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Rights = new RightsBlock[count];
            for (int j = 0; j < count; j++)
            { Rights[j] = new RightsBlock(bytes, ref i); }
        }

        public GrantUserRightsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Rights = new RightsBlock[count];
            for (int j = 0; j < count; j++)
            { Rights[j] = new RightsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Rights.Length; j++) { length += Rights[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Rights.Length;
            for (int j = 0; j < Rights.Length; j++) { Rights[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GrantUserRights ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Rights.Length; j++)
            {
                output += Rights[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ChangeUserRightsPacket : Packet
    {
        /// <exclude/>
        [XmlType("changeuserrights_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("changeuserrights_rights")]
        public class RightsBlock
        {
            public LLUUID AgentRelated;
            public int RelatedRights;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public RightsBlock() { }
            public RightsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentRelated = new LLUUID(bytes, i); i += 16;
                    RelatedRights = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentRelated.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(RelatedRights % 256);
                bytes[i++] = (byte)((RelatedRights >> 8) % 256);
                bytes[i++] = (byte)((RelatedRights >> 16) % 256);
                bytes[i++] = (byte)((RelatedRights >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Rights --");
                output.AppendLine(String.Format("AgentRelated: {0}", AgentRelated));
                output.Append(String.Format("RelatedRights: {0}", RelatedRights));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChangeUserRights; } }
        public AgentDataBlock AgentData;
        public RightsBlock[] Rights;

        public ChangeUserRightsPacket()
        {
            Header = new LowHeader();
            Header.ID = 321;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Rights = new RightsBlock[0];
        }

        public ChangeUserRightsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Rights = new RightsBlock[count];
            for (int j = 0; j < count; j++)
            { Rights[j] = new RightsBlock(bytes, ref i); }
        }

        public ChangeUserRightsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Rights = new RightsBlock[count];
            for (int j = 0; j < count; j++)
            { Rights[j] = new RightsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Rights.Length; j++) { length += Rights[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Rights.Length;
            for (int j = 0; j < Rights.Length; j++) { Rights[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChangeUserRights ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Rights.Length; j++)
            {
                output += Rights[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class OnlineNotificationPacket : Packet
    {
        /// <exclude/>
        [XmlType("onlinenotification_agentblock")]
        public class AgentBlockBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentBlockBlock() { }
            public AgentBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentBlock --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.OnlineNotification; } }
        public AgentBlockBlock[] AgentBlock;

        public OnlineNotificationPacket()
        {
            Header = new LowHeader();
            Header.ID = 322;
            Header.Reliable = true;
            AgentBlock = new AgentBlockBlock[0];
        }

        public OnlineNotificationPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            AgentBlock = new AgentBlockBlock[count];
            for (int j = 0; j < count; j++)
            { AgentBlock[j] = new AgentBlockBlock(bytes, ref i); }
        }

        public OnlineNotificationPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            AgentBlock = new AgentBlockBlock[count];
            for (int j = 0; j < count; j++)
            { AgentBlock[j] = new AgentBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < AgentBlock.Length; j++) { length += AgentBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)AgentBlock.Length;
            for (int j = 0; j < AgentBlock.Length; j++) { AgentBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- OnlineNotification ---" + Environment.NewLine;
            for (int j = 0; j < AgentBlock.Length; j++)
            {
                output += AgentBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class OfflineNotificationPacket : Packet
    {
        /// <exclude/>
        [XmlType("offlinenotification_agentblock")]
        public class AgentBlockBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentBlockBlock() { }
            public AgentBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentBlock --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.OfflineNotification; } }
        public AgentBlockBlock[] AgentBlock;

        public OfflineNotificationPacket()
        {
            Header = new LowHeader();
            Header.ID = 323;
            Header.Reliable = true;
            AgentBlock = new AgentBlockBlock[0];
        }

        public OfflineNotificationPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            AgentBlock = new AgentBlockBlock[count];
            for (int j = 0; j < count; j++)
            { AgentBlock[j] = new AgentBlockBlock(bytes, ref i); }
        }

        public OfflineNotificationPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            AgentBlock = new AgentBlockBlock[count];
            for (int j = 0; j < count; j++)
            { AgentBlock[j] = new AgentBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < AgentBlock.Length; j++) { length += AgentBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)AgentBlock.Length;
            for (int j = 0; j < AgentBlock.Length; j++) { AgentBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- OfflineNotification ---" + Environment.NewLine;
            for (int j = 0; j < AgentBlock.Length; j++)
            {
                output += AgentBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class SetStartLocationRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("setstartlocationrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("setstartlocationrequest_startlocationdata")]
        public class StartLocationDataBlock
        {
            private byte[] _simname;
            public byte[] SimName
            {
                get { return _simname; }
                set
                {
                    if (value == null) { _simname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
                }
            }
            public uint LocationID;
            public LLVector3 LocationPos;
            public LLVector3 LocationLookAt;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (SimName != null) { length += 1 + SimName.Length; }
                    return length;
                }
            }

            public StartLocationDataBlock() { }
            public StartLocationDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _simname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
                    LocationID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LocationPos = new LLVector3(bytes, i); i += 12;
                    LocationLookAt = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimName.Length;
                Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
                bytes[i++] = (byte)(LocationID % 256);
                bytes[i++] = (byte)((LocationID >> 8) % 256);
                bytes[i++] = (byte)((LocationID >> 16) % 256);
                bytes[i++] = (byte)((LocationID >> 24) % 256);
                Buffer.BlockCopy(LocationPos.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LocationLookAt.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- StartLocationData --");
                Helpers.FieldToString(output, SimName, "SimName");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("LocationID: {0}", LocationID));
                output.AppendLine(String.Format("LocationPos: {0}", LocationPos));
                output.Append(String.Format("LocationLookAt: {0}", LocationLookAt));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SetStartLocationRequest; } }
        public AgentDataBlock AgentData;
        public StartLocationDataBlock StartLocationData;

        public SetStartLocationRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 324;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            StartLocationData = new StartLocationDataBlock();
        }

        public SetStartLocationRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            StartLocationData = new StartLocationDataBlock(bytes, ref i);
        }

        public SetStartLocationRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            StartLocationData = new StartLocationDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += StartLocationData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            StartLocationData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SetStartLocationRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += StartLocationData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AssetUploadRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("assetuploadrequest_assetblock")]
        public class AssetBlockBlock
        {
            public LLUUID TransactionID;
            public sbyte Type;
            public bool Tempfile;
            public bool StoreLocal;
            private byte[] _assetdata;
            public byte[] AssetData
            {
                get { return _assetdata; }
                set
                {
                    if (value == null) { _assetdata = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _assetdata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _assetdata, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 19;
                    if (AssetData != null) { length += 2 + AssetData.Length; }
                    return length;
                }
            }

            public AssetBlockBlock() { }
            public AssetBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    Tempfile = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    StoreLocal = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _assetdata = new byte[length];
                    Buffer.BlockCopy(bytes, i, _assetdata, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)((Tempfile) ? 1 : 0);
                bytes[i++] = (byte)((StoreLocal) ? 1 : 0);
                if(AssetData == null) { Console.WriteLine("Warning: AssetData is null, in " + this.GetType()); }
                bytes[i++] = (byte)(AssetData.Length % 256);
                bytes[i++] = (byte)((AssetData.Length >> 8) % 256);
                Buffer.BlockCopy(AssetData, 0, bytes, i, AssetData.Length); i += AssetData.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AssetBlock --");
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("Tempfile: {0}", Tempfile));
                output.AppendLine(String.Format("StoreLocal: {0}", StoreLocal));
                Helpers.FieldToString(output, AssetData, "AssetData");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AssetUploadRequest; } }
        public AssetBlockBlock AssetBlock;

        public AssetUploadRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 333;
            Header.Reliable = true;
            AssetBlock = new AssetBlockBlock();
        }

        public AssetUploadRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AssetBlock = new AssetBlockBlock(bytes, ref i);
        }

        public AssetUploadRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AssetBlock = new AssetBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AssetBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AssetBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AssetUploadRequest ---" + Environment.NewLine;
                output += AssetBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AssetUploadCompletePacket : Packet
    {
        /// <exclude/>
        [XmlType("assetuploadcomplete_assetblock")]
        public class AssetBlockBlock
        {
            public LLUUID UUID;
            public sbyte Type;
            public bool Success;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 18;
                }
            }

            public AssetBlockBlock() { }
            public AssetBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    UUID = new LLUUID(bytes, i); i += 16;
                    Type = (sbyte)bytes[i++];
                    Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(UUID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)Type;
                bytes[i++] = (byte)((Success) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AssetBlock --");
                output.AppendLine(String.Format("UUID: {0}", UUID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.Append(String.Format("Success: {0}", Success));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AssetUploadComplete; } }
        public AssetBlockBlock AssetBlock;

        public AssetUploadCompletePacket()
        {
            Header = new LowHeader();
            Header.ID = 334;
            Header.Reliable = true;
            AssetBlock = new AssetBlockBlock();
        }

        public AssetUploadCompletePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AssetBlock = new AssetBlockBlock(bytes, ref i);
        }

        public AssetUploadCompletePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AssetBlock = new AssetBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AssetBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AssetBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AssetUploadComplete ---" + Environment.NewLine;
                output += AssetBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateGroupRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("creategrouprequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("creategrouprequest_groupdata")]
        public class GroupDataBlock
        {
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _charter;
            public byte[] Charter
            {
                get { return _charter; }
                set
                {
                    if (value == null) { _charter = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _charter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _charter, 0, value.Length); }
                }
            }
            public bool ShowInList;
            public LLUUID InsigniaID;
            public int MembershipFee;
            public bool OpenEnrollment;
            public bool AllowPublish;
            public bool MaturePublish;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Charter != null) { length += 2 + Charter.Length; }
                    return length;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _charter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _charter, 0, length); i += length;
                    ShowInList = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    InsigniaID = new LLUUID(bytes, i); i += 16;
                    MembershipFee = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OpenEnrollment = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Charter == null) { Console.WriteLine("Warning: Charter is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Charter.Length % 256);
                bytes[i++] = (byte)((Charter.Length >> 8) % 256);
                Buffer.BlockCopy(Charter, 0, bytes, i, Charter.Length); i += Charter.Length;
                bytes[i++] = (byte)((ShowInList) ? 1 : 0);
                Buffer.BlockCopy(InsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(MembershipFee % 256);
                bytes[i++] = (byte)((MembershipFee >> 8) % 256);
                bytes[i++] = (byte)((MembershipFee >> 16) % 256);
                bytes[i++] = (byte)((MembershipFee >> 24) % 256);
                bytes[i++] = (byte)((OpenEnrollment) ? 1 : 0);
                bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
                bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Charter, "Charter");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ShowInList: {0}", ShowInList));
                output.AppendLine(String.Format("InsigniaID: {0}", InsigniaID));
                output.AppendLine(String.Format("MembershipFee: {0}", MembershipFee));
                output.AppendLine(String.Format("OpenEnrollment: {0}", OpenEnrollment));
                output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
                output.Append(String.Format("MaturePublish: {0}", MaturePublish));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateGroupRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public CreateGroupRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 339;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public CreateGroupRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public CreateGroupRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateGroupRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateGroupReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("creategroupreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("creategroupreply_replydata")]
        public class ReplyDataBlock
        {
            public LLUUID GroupID;
            public bool Success;
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 17;
                    if (Message != null) { length += 1 + Message.Length; }
                    return length;
                }
            }

            public ReplyDataBlock() { }
            public ReplyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Success) ? 1 : 0);
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)Message.Length;
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ReplyData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("Success: {0}", Success));
                Helpers.FieldToString(output, Message, "Message");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateGroupReply; } }
        public AgentDataBlock AgentData;
        public ReplyDataBlock ReplyData;

        public CreateGroupReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 340;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ReplyData = new ReplyDataBlock();
        }

        public CreateGroupReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ReplyData = new ReplyDataBlock(bytes, ref i);
        }

        public CreateGroupReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ReplyData = new ReplyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ReplyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ReplyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateGroupReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ReplyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UpdateGroupInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("updategroupinfo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updategroupinfo_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            private byte[] _charter;
            public byte[] Charter
            {
                get { return _charter; }
                set
                {
                    if (value == null) { _charter = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _charter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _charter, 0, value.Length); }
                }
            }
            public bool ShowInList;
            public LLUUID InsigniaID;
            public int MembershipFee;
            public bool OpenEnrollment;
            public bool AllowPublish;
            public bool MaturePublish;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 40;
                    if (Charter != null) { length += 2 + Charter.Length; }
                    return length;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _charter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _charter, 0, length); i += length;
                    ShowInList = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    InsigniaID = new LLUUID(bytes, i); i += 16;
                    MembershipFee = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OpenEnrollment = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Charter == null) { Console.WriteLine("Warning: Charter is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Charter.Length % 256);
                bytes[i++] = (byte)((Charter.Length >> 8) % 256);
                Buffer.BlockCopy(Charter, 0, bytes, i, Charter.Length); i += Charter.Length;
                bytes[i++] = (byte)((ShowInList) ? 1 : 0);
                Buffer.BlockCopy(InsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(MembershipFee % 256);
                bytes[i++] = (byte)((MembershipFee >> 8) % 256);
                bytes[i++] = (byte)((MembershipFee >> 16) % 256);
                bytes[i++] = (byte)((MembershipFee >> 24) % 256);
                bytes[i++] = (byte)((OpenEnrollment) ? 1 : 0);
                bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
                bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                Helpers.FieldToString(output, Charter, "Charter");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ShowInList: {0}", ShowInList));
                output.AppendLine(String.Format("InsigniaID: {0}", InsigniaID));
                output.AppendLine(String.Format("MembershipFee: {0}", MembershipFee));
                output.AppendLine(String.Format("OpenEnrollment: {0}", OpenEnrollment));
                output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
                output.Append(String.Format("MaturePublish: {0}", MaturePublish));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateGroupInfo; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public UpdateGroupInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 341;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public UpdateGroupInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public UpdateGroupInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateGroupInfo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupRoleChangesPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouprolechanges_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouprolechanges_rolechange")]
        public class RoleChangeBlock
        {
            public LLUUID RoleID;
            public LLUUID MemberID;
            public uint Change;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public RoleChangeBlock() { }
            public RoleChangeBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RoleID = new LLUUID(bytes, i); i += 16;
                    MemberID = new LLUUID(bytes, i); i += 16;
                    Change = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(MemberID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Change % 256);
                bytes[i++] = (byte)((Change >> 8) % 256);
                bytes[i++] = (byte)((Change >> 16) % 256);
                bytes[i++] = (byte)((Change >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RoleChange --");
                output.AppendLine(String.Format("RoleID: {0}", RoleID));
                output.AppendLine(String.Format("MemberID: {0}", MemberID));
                output.Append(String.Format("Change: {0}", Change));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupRoleChanges; } }
        public AgentDataBlock AgentData;
        public RoleChangeBlock[] RoleChange;

        public GroupRoleChangesPacket()
        {
            Header = new LowHeader();
            Header.ID = 342;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RoleChange = new RoleChangeBlock[0];
        }

        public GroupRoleChangesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RoleChange = new RoleChangeBlock[count];
            for (int j = 0; j < count; j++)
            { RoleChange[j] = new RoleChangeBlock(bytes, ref i); }
        }

        public GroupRoleChangesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RoleChange = new RoleChangeBlock[count];
            for (int j = 0; j < count; j++)
            { RoleChange[j] = new RoleChangeBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < RoleChange.Length; j++) { length += RoleChange[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)RoleChange.Length;
            for (int j = 0; j < RoleChange.Length; j++) { RoleChange[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupRoleChanges ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < RoleChange.Length; j++)
            {
                output += RoleChange[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class JoinGroupRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("joingrouprequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("joingrouprequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.JoinGroupRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public JoinGroupRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 343;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public JoinGroupRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public JoinGroupRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- JoinGroupRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class JoinGroupReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("joingroupreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("joingroupreply_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public bool Success;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Success) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("Success: {0}", Success));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.JoinGroupReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public JoinGroupReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 344;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public JoinGroupReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public JoinGroupReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- JoinGroupReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class EjectGroupMemberRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("ejectgroupmemberrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("ejectgroupmemberrequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("ejectgroupmemberrequest_ejectdata")]
        public class EjectDataBlock
        {
            public LLUUID EjecteeID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public EjectDataBlock() { }
            public EjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EjecteeID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(EjecteeID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EjectData --");
                output.Append(String.Format("EjecteeID: {0}", EjecteeID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EjectGroupMemberRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public EjectDataBlock[] EjectData;

        public EjectGroupMemberRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 345;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            EjectData = new EjectDataBlock[0];
        }

        public EjectGroupMemberRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            EjectData = new EjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { EjectData[j] = new EjectDataBlock(bytes, ref i); }
        }

        public EjectGroupMemberRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            EjectData = new EjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { EjectData[j] = new EjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            length++;
            for (int j = 0; j < EjectData.Length; j++) { length += EjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)EjectData.Length;
            for (int j = 0; j < EjectData.Length; j++) { EjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EjectGroupMemberRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            for (int j = 0; j < EjectData.Length; j++)
            {
                output += EjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class EjectGroupMemberReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("ejectgroupmemberreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("ejectgroupmemberreply_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("ejectgroupmemberreply_ejectdata")]
        public class EjectDataBlock
        {
            public bool Success;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public EjectDataBlock() { }
            public EjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((Success) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- EjectData --");
                output.Append(String.Format("Success: {0}", Success));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.EjectGroupMemberReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public EjectDataBlock EjectData;

        public EjectGroupMemberReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 346;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            EjectData = new EjectDataBlock();
        }

        public EjectGroupMemberReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            EjectData = new EjectDataBlock(bytes, ref i);
        }

        public EjectGroupMemberReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            EjectData = new EjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;            length += EjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            EjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- EjectGroupMemberReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
                output += EjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LeaveGroupRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("leavegrouprequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("leavegrouprequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LeaveGroupRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public LeaveGroupRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 347;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public LeaveGroupRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public LeaveGroupRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LeaveGroupRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LeaveGroupReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("leavegroupreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("leavegroupreply_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public bool Success;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Success) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("Success: {0}", Success));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LeaveGroupReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public LeaveGroupReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 348;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public LeaveGroupReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public LeaveGroupReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LeaveGroupReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class InviteGroupRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("invitegrouprequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("invitegrouprequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("invitegrouprequest_invitedata")]
        public class InviteDataBlock
        {
            public LLUUID InviteeID;
            public LLUUID RoleID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public InviteDataBlock() { }
            public InviteDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    InviteeID = new LLUUID(bytes, i); i += 16;
                    RoleID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(InviteeID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- InviteData --");
                output.AppendLine(String.Format("InviteeID: {0}", InviteeID));
                output.Append(String.Format("RoleID: {0}", RoleID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.InviteGroupRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public InviteDataBlock[] InviteData;

        public InviteGroupRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 349;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            InviteData = new InviteDataBlock[0];
        }

        public InviteGroupRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InviteData = new InviteDataBlock[count];
            for (int j = 0; j < count; j++)
            { InviteData[j] = new InviteDataBlock(bytes, ref i); }
        }

        public InviteGroupRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            InviteData = new InviteDataBlock[count];
            for (int j = 0; j < count; j++)
            { InviteData[j] = new InviteDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            length++;
            for (int j = 0; j < InviteData.Length; j++) { length += InviteData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)InviteData.Length;
            for (int j = 0; j < InviteData.Length; j++) { InviteData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- InviteGroupRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            for (int j = 0; j < InviteData.Length; j++)
            {
                output += InviteData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupProfileRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupprofilerequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupprofilerequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupProfileRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public GroupProfileRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 351;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public GroupProfileRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public GroupProfileRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupProfileRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupProfileReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupprofilereply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupprofilereply_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _charter;
            public byte[] Charter
            {
                get { return _charter; }
                set
                {
                    if (value == null) { _charter = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _charter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _charter, 0, value.Length); }
                }
            }
            public bool ShowInList;
            private byte[] _membertitle;
            public byte[] MemberTitle
            {
                get { return _membertitle; }
                set
                {
                    if (value == null) { _membertitle = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _membertitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _membertitle, 0, value.Length); }
                }
            }
            public ulong PowersMask;
            public LLUUID InsigniaID;
            public LLUUID FounderID;
            public int MembershipFee;
            public bool OpenEnrollment;
            public int Money;
            public int GroupMembershipCount;
            public int GroupRolesCount;
            public bool AllowPublish;
            public bool MaturePublish;
            public LLUUID OwnerRole;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 92;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Charter != null) { length += 2 + Charter.Length; }
                    if (MemberTitle != null) { length += 1 + MemberTitle.Length; }
                    return length;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _charter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _charter, 0, length); i += length;
                    ShowInList = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _membertitle = new byte[length];
                    Buffer.BlockCopy(bytes, i, _membertitle, 0, length); i += length;
                    PowersMask = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    InsigniaID = new LLUUID(bytes, i); i += 16;
                    FounderID = new LLUUID(bytes, i); i += 16;
                    MembershipFee = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OpenEnrollment = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    Money = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMembershipCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupRolesCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    OwnerRole = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Charter == null) { Console.WriteLine("Warning: Charter is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Charter.Length % 256);
                bytes[i++] = (byte)((Charter.Length >> 8) % 256);
                Buffer.BlockCopy(Charter, 0, bytes, i, Charter.Length); i += Charter.Length;
                bytes[i++] = (byte)((ShowInList) ? 1 : 0);
                if(MemberTitle == null) { Console.WriteLine("Warning: MemberTitle is null, in " + this.GetType()); }
                bytes[i++] = (byte)MemberTitle.Length;
                Buffer.BlockCopy(MemberTitle, 0, bytes, i, MemberTitle.Length); i += MemberTitle.Length;
                bytes[i++] = (byte)(PowersMask % 256);
                bytes[i++] = (byte)((PowersMask >> 8) % 256);
                bytes[i++] = (byte)((PowersMask >> 16) % 256);
                bytes[i++] = (byte)((PowersMask >> 24) % 256);
                bytes[i++] = (byte)((PowersMask >> 32) % 256);
                bytes[i++] = (byte)((PowersMask >> 40) % 256);
                bytes[i++] = (byte)((PowersMask >> 48) % 256);
                bytes[i++] = (byte)((PowersMask >> 56) % 256);
                Buffer.BlockCopy(InsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FounderID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(MembershipFee % 256);
                bytes[i++] = (byte)((MembershipFee >> 8) % 256);
                bytes[i++] = (byte)((MembershipFee >> 16) % 256);
                bytes[i++] = (byte)((MembershipFee >> 24) % 256);
                bytes[i++] = (byte)((OpenEnrollment) ? 1 : 0);
                bytes[i++] = (byte)(Money % 256);
                bytes[i++] = (byte)((Money >> 8) % 256);
                bytes[i++] = (byte)((Money >> 16) % 256);
                bytes[i++] = (byte)((Money >> 24) % 256);
                bytes[i++] = (byte)(GroupMembershipCount % 256);
                bytes[i++] = (byte)((GroupMembershipCount >> 8) % 256);
                bytes[i++] = (byte)((GroupMembershipCount >> 16) % 256);
                bytes[i++] = (byte)((GroupMembershipCount >> 24) % 256);
                bytes[i++] = (byte)(GroupRolesCount % 256);
                bytes[i++] = (byte)((GroupRolesCount >> 8) % 256);
                bytes[i++] = (byte)((GroupRolesCount >> 16) % 256);
                bytes[i++] = (byte)((GroupRolesCount >> 24) % 256);
                bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
                bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
                Buffer.BlockCopy(OwnerRole.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Charter, "Charter");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ShowInList: {0}", ShowInList));
                Helpers.FieldToString(output, MemberTitle, "MemberTitle");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("PowersMask: {0}", PowersMask));
                output.AppendLine(String.Format("InsigniaID: {0}", InsigniaID));
                output.AppendLine(String.Format("FounderID: {0}", FounderID));
                output.AppendLine(String.Format("MembershipFee: {0}", MembershipFee));
                output.AppendLine(String.Format("OpenEnrollment: {0}", OpenEnrollment));
                output.AppendLine(String.Format("Money: {0}", Money));
                output.AppendLine(String.Format("GroupMembershipCount: {0}", GroupMembershipCount));
                output.AppendLine(String.Format("GroupRolesCount: {0}", GroupRolesCount));
                output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
                output.AppendLine(String.Format("MaturePublish: {0}", MaturePublish));
                output.Append(String.Format("OwnerRole: {0}", OwnerRole));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupProfileReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public GroupProfileReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 352;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public GroupProfileReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public GroupProfileReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupProfileReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupAccountSummaryRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupaccountsummaryrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccountsummaryrequest_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID RequestID;
            public int IntervalDays;
            public int CurrentInterval;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IntervalDays % 256);
                bytes[i++] = (byte)((IntervalDays >> 8) % 256);
                bytes[i++] = (byte)((IntervalDays >> 16) % 256);
                bytes[i++] = (byte)((IntervalDays >> 24) % 256);
                bytes[i++] = (byte)(CurrentInterval % 256);
                bytes[i++] = (byte)((CurrentInterval >> 8) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 16) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
                output.Append(String.Format("CurrentInterval: {0}", CurrentInterval));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupAccountSummaryRequest; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;

        public GroupAccountSummaryRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 353;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
        }

        public GroupAccountSummaryRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public GroupAccountSummaryRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupAccountSummaryRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupAccountSummaryReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupaccountsummaryreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccountsummaryreply_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID RequestID;
            public int IntervalDays;
            public int CurrentInterval;
            private byte[] _startdate;
            public byte[] StartDate
            {
                get { return _startdate; }
                set
                {
                    if (value == null) { _startdate = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _startdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdate, 0, value.Length); }
                }
            }
            public int Balance;
            public int TotalCredits;
            public int TotalDebits;
            public int ObjectTaxCurrent;
            public int LightTaxCurrent;
            public int LandTaxCurrent;
            public int GroupTaxCurrent;
            public int ParcelDirFeeCurrent;
            public int ObjectTaxEstimate;
            public int LightTaxEstimate;
            public int LandTaxEstimate;
            public int GroupTaxEstimate;
            public int ParcelDirFeeEstimate;
            public int NonExemptMembers;
            private byte[] _lasttaxdate;
            public byte[] LastTaxDate
            {
                get { return _lasttaxdate; }
                set
                {
                    if (value == null) { _lasttaxdate = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _lasttaxdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lasttaxdate, 0, value.Length); }
                }
            }
            private byte[] _taxdate;
            public byte[] TaxDate
            {
                get { return _taxdate; }
                set
                {
                    if (value == null) { _taxdate = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _taxdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _taxdate, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 80;
                    if (StartDate != null) { length += 1 + StartDate.Length; }
                    if (LastTaxDate != null) { length += 1 + LastTaxDate.Length; }
                    if (TaxDate != null) { length += 1 + TaxDate.Length; }
                    return length;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _startdate = new byte[length];
                    Buffer.BlockCopy(bytes, i, _startdate, 0, length); i += length;
                    Balance = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TotalCredits = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TotalDebits = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ObjectTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LightTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LandTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParcelDirFeeCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ObjectTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LightTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LandTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParcelDirFeeEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NonExemptMembers = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _lasttaxdate = new byte[length];
                    Buffer.BlockCopy(bytes, i, _lasttaxdate, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _taxdate = new byte[length];
                    Buffer.BlockCopy(bytes, i, _taxdate, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IntervalDays % 256);
                bytes[i++] = (byte)((IntervalDays >> 8) % 256);
                bytes[i++] = (byte)((IntervalDays >> 16) % 256);
                bytes[i++] = (byte)((IntervalDays >> 24) % 256);
                bytes[i++] = (byte)(CurrentInterval % 256);
                bytes[i++] = (byte)((CurrentInterval >> 8) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 16) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 24) % 256);
                if(StartDate == null) { Console.WriteLine("Warning: StartDate is null, in " + this.GetType()); }
                bytes[i++] = (byte)StartDate.Length;
                Buffer.BlockCopy(StartDate, 0, bytes, i, StartDate.Length); i += StartDate.Length;
                bytes[i++] = (byte)(Balance % 256);
                bytes[i++] = (byte)((Balance >> 8) % 256);
                bytes[i++] = (byte)((Balance >> 16) % 256);
                bytes[i++] = (byte)((Balance >> 24) % 256);
                bytes[i++] = (byte)(TotalCredits % 256);
                bytes[i++] = (byte)((TotalCredits >> 8) % 256);
                bytes[i++] = (byte)((TotalCredits >> 16) % 256);
                bytes[i++] = (byte)((TotalCredits >> 24) % 256);
                bytes[i++] = (byte)(TotalDebits % 256);
                bytes[i++] = (byte)((TotalDebits >> 8) % 256);
                bytes[i++] = (byte)((TotalDebits >> 16) % 256);
                bytes[i++] = (byte)((TotalDebits >> 24) % 256);
                bytes[i++] = (byte)(ObjectTaxCurrent % 256);
                bytes[i++] = (byte)((ObjectTaxCurrent >> 8) % 256);
                bytes[i++] = (byte)((ObjectTaxCurrent >> 16) % 256);
                bytes[i++] = (byte)((ObjectTaxCurrent >> 24) % 256);
                bytes[i++] = (byte)(LightTaxCurrent % 256);
                bytes[i++] = (byte)((LightTaxCurrent >> 8) % 256);
                bytes[i++] = (byte)((LightTaxCurrent >> 16) % 256);
                bytes[i++] = (byte)((LightTaxCurrent >> 24) % 256);
                bytes[i++] = (byte)(LandTaxCurrent % 256);
                bytes[i++] = (byte)((LandTaxCurrent >> 8) % 256);
                bytes[i++] = (byte)((LandTaxCurrent >> 16) % 256);
                bytes[i++] = (byte)((LandTaxCurrent >> 24) % 256);
                bytes[i++] = (byte)(GroupTaxCurrent % 256);
                bytes[i++] = (byte)((GroupTaxCurrent >> 8) % 256);
                bytes[i++] = (byte)((GroupTaxCurrent >> 16) % 256);
                bytes[i++] = (byte)((GroupTaxCurrent >> 24) % 256);
                bytes[i++] = (byte)(ParcelDirFeeCurrent % 256);
                bytes[i++] = (byte)((ParcelDirFeeCurrent >> 8) % 256);
                bytes[i++] = (byte)((ParcelDirFeeCurrent >> 16) % 256);
                bytes[i++] = (byte)((ParcelDirFeeCurrent >> 24) % 256);
                bytes[i++] = (byte)(ObjectTaxEstimate % 256);
                bytes[i++] = (byte)((ObjectTaxEstimate >> 8) % 256);
                bytes[i++] = (byte)((ObjectTaxEstimate >> 16) % 256);
                bytes[i++] = (byte)((ObjectTaxEstimate >> 24) % 256);
                bytes[i++] = (byte)(LightTaxEstimate % 256);
                bytes[i++] = (byte)((LightTaxEstimate >> 8) % 256);
                bytes[i++] = (byte)((LightTaxEstimate >> 16) % 256);
                bytes[i++] = (byte)((LightTaxEstimate >> 24) % 256);
                bytes[i++] = (byte)(LandTaxEstimate % 256);
                bytes[i++] = (byte)((LandTaxEstimate >> 8) % 256);
                bytes[i++] = (byte)((LandTaxEstimate >> 16) % 256);
                bytes[i++] = (byte)((LandTaxEstimate >> 24) % 256);
                bytes[i++] = (byte)(GroupTaxEstimate % 256);
                bytes[i++] = (byte)((GroupTaxEstimate >> 8) % 256);
                bytes[i++] = (byte)((GroupTaxEstimate >> 16) % 256);
                bytes[i++] = (byte)((GroupTaxEstimate >> 24) % 256);
                bytes[i++] = (byte)(ParcelDirFeeEstimate % 256);
                bytes[i++] = (byte)((ParcelDirFeeEstimate >> 8) % 256);
                bytes[i++] = (byte)((ParcelDirFeeEstimate >> 16) % 256);
                bytes[i++] = (byte)((ParcelDirFeeEstimate >> 24) % 256);
                bytes[i++] = (byte)(NonExemptMembers % 256);
                bytes[i++] = (byte)((NonExemptMembers >> 8) % 256);
                bytes[i++] = (byte)((NonExemptMembers >> 16) % 256);
                bytes[i++] = (byte)((NonExemptMembers >> 24) % 256);
                if(LastTaxDate == null) { Console.WriteLine("Warning: LastTaxDate is null, in " + this.GetType()); }
                bytes[i++] = (byte)LastTaxDate.Length;
                Buffer.BlockCopy(LastTaxDate, 0, bytes, i, LastTaxDate.Length); i += LastTaxDate.Length;
                if(TaxDate == null) { Console.WriteLine("Warning: TaxDate is null, in " + this.GetType()); }
                bytes[i++] = (byte)TaxDate.Length;
                Buffer.BlockCopy(TaxDate, 0, bytes, i, TaxDate.Length); i += TaxDate.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
                output.AppendLine(String.Format("CurrentInterval: {0}", CurrentInterval));
                Helpers.FieldToString(output, StartDate, "StartDate");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Balance: {0}", Balance));
                output.AppendLine(String.Format("TotalCredits: {0}", TotalCredits));
                output.AppendLine(String.Format("TotalDebits: {0}", TotalDebits));
                output.AppendLine(String.Format("ObjectTaxCurrent: {0}", ObjectTaxCurrent));
                output.AppendLine(String.Format("LightTaxCurrent: {0}", LightTaxCurrent));
                output.AppendLine(String.Format("LandTaxCurrent: {0}", LandTaxCurrent));
                output.AppendLine(String.Format("GroupTaxCurrent: {0}", GroupTaxCurrent));
                output.AppendLine(String.Format("ParcelDirFeeCurrent: {0}", ParcelDirFeeCurrent));
                output.AppendLine(String.Format("ObjectTaxEstimate: {0}", ObjectTaxEstimate));
                output.AppendLine(String.Format("LightTaxEstimate: {0}", LightTaxEstimate));
                output.AppendLine(String.Format("LandTaxEstimate: {0}", LandTaxEstimate));
                output.AppendLine(String.Format("GroupTaxEstimate: {0}", GroupTaxEstimate));
                output.AppendLine(String.Format("ParcelDirFeeEstimate: {0}", ParcelDirFeeEstimate));
                output.AppendLine(String.Format("NonExemptMembers: {0}", NonExemptMembers));
                Helpers.FieldToString(output, LastTaxDate, "LastTaxDate");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TaxDate, "TaxDate");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupAccountSummaryReply; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;

        public GroupAccountSummaryReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 354;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
        }

        public GroupAccountSummaryReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public GroupAccountSummaryReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupAccountSummaryReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupAccountDetailsRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupaccountdetailsrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccountdetailsrequest_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID RequestID;
            public int IntervalDays;
            public int CurrentInterval;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IntervalDays % 256);
                bytes[i++] = (byte)((IntervalDays >> 8) % 256);
                bytes[i++] = (byte)((IntervalDays >> 16) % 256);
                bytes[i++] = (byte)((IntervalDays >> 24) % 256);
                bytes[i++] = (byte)(CurrentInterval % 256);
                bytes[i++] = (byte)((CurrentInterval >> 8) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 16) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
                output.Append(String.Format("CurrentInterval: {0}", CurrentInterval));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupAccountDetailsRequest; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;

        public GroupAccountDetailsRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 355;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
        }

        public GroupAccountDetailsRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public GroupAccountDetailsRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupAccountDetailsRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupAccountDetailsReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupaccountdetailsreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccountdetailsreply_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID RequestID;
            public int IntervalDays;
            public int CurrentInterval;
            private byte[] _startdate;
            public byte[] StartDate
            {
                get { return _startdate; }
                set
                {
                    if (value == null) { _startdate = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _startdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdate, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (StartDate != null) { length += 1 + StartDate.Length; }
                    return length;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _startdate = new byte[length];
                    Buffer.BlockCopy(bytes, i, _startdate, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IntervalDays % 256);
                bytes[i++] = (byte)((IntervalDays >> 8) % 256);
                bytes[i++] = (byte)((IntervalDays >> 16) % 256);
                bytes[i++] = (byte)((IntervalDays >> 24) % 256);
                bytes[i++] = (byte)(CurrentInterval % 256);
                bytes[i++] = (byte)((CurrentInterval >> 8) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 16) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 24) % 256);
                if(StartDate == null) { Console.WriteLine("Warning: StartDate is null, in " + this.GetType()); }
                bytes[i++] = (byte)StartDate.Length;
                Buffer.BlockCopy(StartDate, 0, bytes, i, StartDate.Length); i += StartDate.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
                output.AppendLine(String.Format("CurrentInterval: {0}", CurrentInterval));
                Helpers.FieldToString(output, StartDate, "StartDate");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccountdetailsreply_historydata")]
        public class HistoryDataBlock
        {
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public int Amount;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public HistoryDataBlock() { }
            public HistoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    Amount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(Amount % 256);
                bytes[i++] = (byte)((Amount >> 8) % 256);
                bytes[i++] = (byte)((Amount >> 16) % 256);
                bytes[i++] = (byte)((Amount >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HistoryData --");
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Amount: {0}", Amount));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupAccountDetailsReply; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;
        public HistoryDataBlock[] HistoryData;

        public GroupAccountDetailsReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 356;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
            HistoryData = new HistoryDataBlock[0];
        }

        public GroupAccountDetailsReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            HistoryData = new HistoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { HistoryData[j] = new HistoryDataBlock(bytes, ref i); }
        }

        public GroupAccountDetailsReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            HistoryData = new HistoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { HistoryData[j] = new HistoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            length++;
            for (int j = 0; j < HistoryData.Length; j++) { length += HistoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)HistoryData.Length;
            for (int j = 0; j < HistoryData.Length; j++) { HistoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupAccountDetailsReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            for (int j = 0; j < HistoryData.Length; j++)
            {
                output += HistoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupAccountTransactionsRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupaccounttransactionsrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccounttransactionsrequest_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID RequestID;
            public int IntervalDays;
            public int CurrentInterval;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IntervalDays % 256);
                bytes[i++] = (byte)((IntervalDays >> 8) % 256);
                bytes[i++] = (byte)((IntervalDays >> 16) % 256);
                bytes[i++] = (byte)((IntervalDays >> 24) % 256);
                bytes[i++] = (byte)(CurrentInterval % 256);
                bytes[i++] = (byte)((CurrentInterval >> 8) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 16) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
                output.Append(String.Format("CurrentInterval: {0}", CurrentInterval));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupAccountTransactionsRequest; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;

        public GroupAccountTransactionsRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 357;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
        }

        public GroupAccountTransactionsRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public GroupAccountTransactionsRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupAccountTransactionsRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupAccountTransactionsReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupaccounttransactionsreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccounttransactionsreply_moneydata")]
        public class MoneyDataBlock
        {
            public LLUUID RequestID;
            public int IntervalDays;
            public int CurrentInterval;
            private byte[] _startdate;
            public byte[] StartDate
            {
                get { return _startdate; }
                set
                {
                    if (value == null) { _startdate = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _startdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdate, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 24;
                    if (StartDate != null) { length += 1 + StartDate.Length; }
                    return length;
                }
            }

            public MoneyDataBlock() { }
            public MoneyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _startdate = new byte[length];
                    Buffer.BlockCopy(bytes, i, _startdate, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(IntervalDays % 256);
                bytes[i++] = (byte)((IntervalDays >> 8) % 256);
                bytes[i++] = (byte)((IntervalDays >> 16) % 256);
                bytes[i++] = (byte)((IntervalDays >> 24) % 256);
                bytes[i++] = (byte)(CurrentInterval % 256);
                bytes[i++] = (byte)((CurrentInterval >> 8) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 16) % 256);
                bytes[i++] = (byte)((CurrentInterval >> 24) % 256);
                if(StartDate == null) { Console.WriteLine("Warning: StartDate is null, in " + this.GetType()); }
                bytes[i++] = (byte)StartDate.Length;
                Buffer.BlockCopy(StartDate, 0, bytes, i, StartDate.Length); i += StartDate.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MoneyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
                output.AppendLine(String.Format("CurrentInterval: {0}", CurrentInterval));
                Helpers.FieldToString(output, StartDate, "StartDate");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupaccounttransactionsreply_historydata")]
        public class HistoryDataBlock
        {
            private byte[] _time;
            public byte[] Time
            {
                get { return _time; }
                set
                {
                    if (value == null) { _time = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _time = new byte[value.Length]; Buffer.BlockCopy(value, 0, _time, 0, value.Length); }
                }
            }
            private byte[] _user;
            public byte[] User
            {
                get { return _user; }
                set
                {
                    if (value == null) { _user = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _user = new byte[value.Length]; Buffer.BlockCopy(value, 0, _user, 0, value.Length); }
                }
            }
            public int Type;
            private byte[] _item;
            public byte[] Item
            {
                get { return _item; }
                set
                {
                    if (value == null) { _item = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _item = new byte[value.Length]; Buffer.BlockCopy(value, 0, _item, 0, value.Length); }
                }
            }
            public int Amount;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 8;
                    if (Time != null) { length += 1 + Time.Length; }
                    if (User != null) { length += 1 + User.Length; }
                    if (Item != null) { length += 1 + Item.Length; }
                    return length;
                }
            }

            public HistoryDataBlock() { }
            public HistoryDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _time = new byte[length];
                    Buffer.BlockCopy(bytes, i, _time, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _user = new byte[length];
                    Buffer.BlockCopy(bytes, i, _user, 0, length); i += length;
                    Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _item = new byte[length];
                    Buffer.BlockCopy(bytes, i, _item, 0, length); i += length;
                    Amount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Time == null) { Console.WriteLine("Warning: Time is null, in " + this.GetType()); }
                bytes[i++] = (byte)Time.Length;
                Buffer.BlockCopy(Time, 0, bytes, i, Time.Length); i += Time.Length;
                if(User == null) { Console.WriteLine("Warning: User is null, in " + this.GetType()); }
                bytes[i++] = (byte)User.Length;
                Buffer.BlockCopy(User, 0, bytes, i, User.Length); i += User.Length;
                bytes[i++] = (byte)(Type % 256);
                bytes[i++] = (byte)((Type >> 8) % 256);
                bytes[i++] = (byte)((Type >> 16) % 256);
                bytes[i++] = (byte)((Type >> 24) % 256);
                if(Item == null) { Console.WriteLine("Warning: Item is null, in " + this.GetType()); }
                bytes[i++] = (byte)Item.Length;
                Buffer.BlockCopy(Item, 0, bytes, i, Item.Length); i += Item.Length;
                bytes[i++] = (byte)(Amount % 256);
                bytes[i++] = (byte)((Amount >> 8) % 256);
                bytes[i++] = (byte)((Amount >> 16) % 256);
                bytes[i++] = (byte)((Amount >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HistoryData --");
                Helpers.FieldToString(output, Time, "Time");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, User, "User");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Type: {0}", Type));
                Helpers.FieldToString(output, Item, "Item");
                output.Append(Environment.NewLine);
                output.Append(String.Format("Amount: {0}", Amount));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupAccountTransactionsReply; } }
        public AgentDataBlock AgentData;
        public MoneyDataBlock MoneyData;
        public HistoryDataBlock[] HistoryData;

        public GroupAccountTransactionsReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 358;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MoneyData = new MoneyDataBlock();
            HistoryData = new HistoryDataBlock[0];
        }

        public GroupAccountTransactionsReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            HistoryData = new HistoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { HistoryData[j] = new HistoryDataBlock(bytes, ref i); }
        }

        public GroupAccountTransactionsReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            MoneyData = new MoneyDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            HistoryData = new HistoryDataBlock[count];
            for (int j = 0; j < count; j++)
            { HistoryData[j] = new HistoryDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += MoneyData.Length;;
            length++;
            for (int j = 0; j < HistoryData.Length; j++) { length += HistoryData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            MoneyData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)HistoryData.Length;
            for (int j = 0; j < HistoryData.Length; j++) { HistoryData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupAccountTransactionsReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += MoneyData.ToString() + Environment.NewLine;
            for (int j = 0; j < HistoryData.Length; j++)
            {
                output += HistoryData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupActiveProposalsRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupactiveproposalsrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupactiveproposalsrequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupactiveproposalsrequest_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupActiveProposalsRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public TransactionDataBlock TransactionData;

        public GroupActiveProposalsRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 359;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            TransactionData = new TransactionDataBlock();
        }

        public GroupActiveProposalsRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
        }

        public GroupActiveProposalsRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;            length += TransactionData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupActiveProposalsRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupActiveProposalItemReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupactiveproposalitemreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupactiveproposalitemreply_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;
            public uint TotalNumItems;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    TotalNumItems = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(TotalNumItems % 256);
                bytes[i++] = (byte)((TotalNumItems >> 8) % 256);
                bytes[i++] = (byte)((TotalNumItems >> 16) % 256);
                bytes[i++] = (byte)((TotalNumItems >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.Append(String.Format("TotalNumItems: {0}", TotalNumItems));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupactiveproposalitemreply_proposaldata")]
        public class ProposalDataBlock
        {
            public LLUUID VoteID;
            public LLUUID VoteInitiator;
            private byte[] _tersedateid;
            public byte[] TerseDateID
            {
                get { return _tersedateid; }
                set
                {
                    if (value == null) { _tersedateid = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _tersedateid = new byte[value.Length]; Buffer.BlockCopy(value, 0, _tersedateid, 0, value.Length); }
                }
            }
            private byte[] _startdatetime;
            public byte[] StartDateTime
            {
                get { return _startdatetime; }
                set
                {
                    if (value == null) { _startdatetime = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _startdatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdatetime, 0, value.Length); }
                }
            }
            private byte[] _enddatetime;
            public byte[] EndDateTime
            {
                get { return _enddatetime; }
                set
                {
                    if (value == null) { _enddatetime = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _enddatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _enddatetime, 0, value.Length); }
                }
            }
            public bool AlreadyVoted;
            private byte[] _votecast;
            public byte[] VoteCast
            {
                get { return _votecast; }
                set
                {
                    if (value == null) { _votecast = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _votecast = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votecast, 0, value.Length); }
                }
            }
            public float Majority;
            public int Quorum;
            private byte[] _proposaltext;
            public byte[] ProposalText
            {
                get { return _proposaltext; }
                set
                {
                    if (value == null) { _proposaltext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _proposaltext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _proposaltext, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 41;
                    if (TerseDateID != null) { length += 1 + TerseDateID.Length; }
                    if (StartDateTime != null) { length += 1 + StartDateTime.Length; }
                    if (EndDateTime != null) { length += 1 + EndDateTime.Length; }
                    if (VoteCast != null) { length += 1 + VoteCast.Length; }
                    if (ProposalText != null) { length += 1 + ProposalText.Length; }
                    return length;
                }
            }

            public ProposalDataBlock() { }
            public ProposalDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    VoteID = new LLUUID(bytes, i); i += 16;
                    VoteInitiator = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _tersedateid = new byte[length];
                    Buffer.BlockCopy(bytes, i, _tersedateid, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _startdatetime = new byte[length];
                    Buffer.BlockCopy(bytes, i, _startdatetime, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _enddatetime = new byte[length];
                    Buffer.BlockCopy(bytes, i, _enddatetime, 0, length); i += length;
                    AlreadyVoted = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _votecast = new byte[length];
                    Buffer.BlockCopy(bytes, i, _votecast, 0, length); i += length;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Majority = BitConverter.ToSingle(bytes, i); i += 4;
                    Quorum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _proposaltext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _proposaltext, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(VoteID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(VoteInitiator.GetBytes(), 0, bytes, i, 16); i += 16;
                if(TerseDateID == null) { Console.WriteLine("Warning: TerseDateID is null, in " + this.GetType()); }
                bytes[i++] = (byte)TerseDateID.Length;
                Buffer.BlockCopy(TerseDateID, 0, bytes, i, TerseDateID.Length); i += TerseDateID.Length;
                if(StartDateTime == null) { Console.WriteLine("Warning: StartDateTime is null, in " + this.GetType()); }
                bytes[i++] = (byte)StartDateTime.Length;
                Buffer.BlockCopy(StartDateTime, 0, bytes, i, StartDateTime.Length); i += StartDateTime.Length;
                if(EndDateTime == null) { Console.WriteLine("Warning: EndDateTime is null, in " + this.GetType()); }
                bytes[i++] = (byte)EndDateTime.Length;
                Buffer.BlockCopy(EndDateTime, 0, bytes, i, EndDateTime.Length); i += EndDateTime.Length;
                bytes[i++] = (byte)((AlreadyVoted) ? 1 : 0);
                if(VoteCast == null) { Console.WriteLine("Warning: VoteCast is null, in " + this.GetType()); }
                bytes[i++] = (byte)VoteCast.Length;
                Buffer.BlockCopy(VoteCast, 0, bytes, i, VoteCast.Length); i += VoteCast.Length;
                ba = BitConverter.GetBytes(Majority);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(Quorum % 256);
                bytes[i++] = (byte)((Quorum >> 8) % 256);
                bytes[i++] = (byte)((Quorum >> 16) % 256);
                bytes[i++] = (byte)((Quorum >> 24) % 256);
                if(ProposalText == null) { Console.WriteLine("Warning: ProposalText is null, in " + this.GetType()); }
                bytes[i++] = (byte)ProposalText.Length;
                Buffer.BlockCopy(ProposalText, 0, bytes, i, ProposalText.Length); i += ProposalText.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ProposalData --");
                output.AppendLine(String.Format("VoteID: {0}", VoteID));
                output.AppendLine(String.Format("VoteInitiator: {0}", VoteInitiator));
                Helpers.FieldToString(output, TerseDateID, "TerseDateID");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, StartDateTime, "StartDateTime");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, EndDateTime, "EndDateTime");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("AlreadyVoted: {0}", AlreadyVoted));
                Helpers.FieldToString(output, VoteCast, "VoteCast");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Majority: {0}", Majority));
                output.AppendLine(String.Format("Quorum: {0}", Quorum));
                Helpers.FieldToString(output, ProposalText, "ProposalText");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupActiveProposalItemReply; } }
        public AgentDataBlock AgentData;
        public TransactionDataBlock TransactionData;
        public ProposalDataBlock[] ProposalData;

        public GroupActiveProposalItemReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 360;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionData = new TransactionDataBlock();
            ProposalData = new ProposalDataBlock[0];
        }

        public GroupActiveProposalItemReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ProposalData = new ProposalDataBlock[count];
            for (int j = 0; j < count; j++)
            { ProposalData[j] = new ProposalDataBlock(bytes, ref i); }
        }

        public GroupActiveProposalItemReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ProposalData = new ProposalDataBlock[count];
            for (int j = 0; j < count; j++)
            { ProposalData[j] = new ProposalDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionData.Length;;
            length++;
            for (int j = 0; j < ProposalData.Length; j++) { length += ProposalData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ProposalData.Length;
            for (int j = 0; j < ProposalData.Length; j++) { ProposalData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupActiveProposalItemReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
            for (int j = 0; j < ProposalData.Length; j++)
            {
                output += ProposalData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupVoteHistoryRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupvotehistoryrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupvotehistoryrequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupvotehistoryrequest_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.Append(String.Format("TransactionID: {0}", TransactionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupVoteHistoryRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public TransactionDataBlock TransactionData;

        public GroupVoteHistoryRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 361;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            TransactionData = new TransactionDataBlock();
        }

        public GroupVoteHistoryRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
        }

        public GroupVoteHistoryRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;            length += TransactionData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupVoteHistoryRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupVoteHistoryItemReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupvotehistoryitemreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupvotehistoryitemreply_transactiondata")]
        public class TransactionDataBlock
        {
            public LLUUID TransactionID;
            public uint TotalNumItems;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public TransactionDataBlock() { }
            public TransactionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TransactionID = new LLUUID(bytes, i); i += 16;
                    TotalNumItems = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(TotalNumItems % 256);
                bytes[i++] = (byte)((TotalNumItems >> 8) % 256);
                bytes[i++] = (byte)((TotalNumItems >> 16) % 256);
                bytes[i++] = (byte)((TotalNumItems >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransactionData --");
                output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
                output.Append(String.Format("TotalNumItems: {0}", TotalNumItems));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupvotehistoryitemreply_historyitemdata")]
        public class HistoryItemDataBlock
        {
            public LLUUID VoteID;
            private byte[] _tersedateid;
            public byte[] TerseDateID
            {
                get { return _tersedateid; }
                set
                {
                    if (value == null) { _tersedateid = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _tersedateid = new byte[value.Length]; Buffer.BlockCopy(value, 0, _tersedateid, 0, value.Length); }
                }
            }
            private byte[] _startdatetime;
            public byte[] StartDateTime
            {
                get { return _startdatetime; }
                set
                {
                    if (value == null) { _startdatetime = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _startdatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdatetime, 0, value.Length); }
                }
            }
            private byte[] _enddatetime;
            public byte[] EndDateTime
            {
                get { return _enddatetime; }
                set
                {
                    if (value == null) { _enddatetime = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _enddatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _enddatetime, 0, value.Length); }
                }
            }
            public LLUUID VoteInitiator;
            private byte[] _votetype;
            public byte[] VoteType
            {
                get { return _votetype; }
                set
                {
                    if (value == null) { _votetype = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _votetype = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votetype, 0, value.Length); }
                }
            }
            private byte[] _voteresult;
            public byte[] VoteResult
            {
                get { return _voteresult; }
                set
                {
                    if (value == null) { _voteresult = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _voteresult = new byte[value.Length]; Buffer.BlockCopy(value, 0, _voteresult, 0, value.Length); }
                }
            }
            public float Majority;
            public int Quorum;
            private byte[] _proposaltext;
            public byte[] ProposalText
            {
                get { return _proposaltext; }
                set
                {
                    if (value == null) { _proposaltext = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _proposaltext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _proposaltext, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 40;
                    if (TerseDateID != null) { length += 1 + TerseDateID.Length; }
                    if (StartDateTime != null) { length += 1 + StartDateTime.Length; }
                    if (EndDateTime != null) { length += 1 + EndDateTime.Length; }
                    if (VoteType != null) { length += 1 + VoteType.Length; }
                    if (VoteResult != null) { length += 1 + VoteResult.Length; }
                    if (ProposalText != null) { length += 2 + ProposalText.Length; }
                    return length;
                }
            }

            public HistoryItemDataBlock() { }
            public HistoryItemDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    VoteID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _tersedateid = new byte[length];
                    Buffer.BlockCopy(bytes, i, _tersedateid, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _startdatetime = new byte[length];
                    Buffer.BlockCopy(bytes, i, _startdatetime, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _enddatetime = new byte[length];
                    Buffer.BlockCopy(bytes, i, _enddatetime, 0, length); i += length;
                    VoteInitiator = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _votetype = new byte[length];
                    Buffer.BlockCopy(bytes, i, _votetype, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _voteresult = new byte[length];
                    Buffer.BlockCopy(bytes, i, _voteresult, 0, length); i += length;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Majority = BitConverter.ToSingle(bytes, i); i += 4;
                    Quorum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _proposaltext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _proposaltext, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(VoteID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(TerseDateID == null) { Console.WriteLine("Warning: TerseDateID is null, in " + this.GetType()); }
                bytes[i++] = (byte)TerseDateID.Length;
                Buffer.BlockCopy(TerseDateID, 0, bytes, i, TerseDateID.Length); i += TerseDateID.Length;
                if(StartDateTime == null) { Console.WriteLine("Warning: StartDateTime is null, in " + this.GetType()); }
                bytes[i++] = (byte)StartDateTime.Length;
                Buffer.BlockCopy(StartDateTime, 0, bytes, i, StartDateTime.Length); i += StartDateTime.Length;
                if(EndDateTime == null) { Console.WriteLine("Warning: EndDateTime is null, in " + this.GetType()); }
                bytes[i++] = (byte)EndDateTime.Length;
                Buffer.BlockCopy(EndDateTime, 0, bytes, i, EndDateTime.Length); i += EndDateTime.Length;
                Buffer.BlockCopy(VoteInitiator.GetBytes(), 0, bytes, i, 16); i += 16;
                if(VoteType == null) { Console.WriteLine("Warning: VoteType is null, in " + this.GetType()); }
                bytes[i++] = (byte)VoteType.Length;
                Buffer.BlockCopy(VoteType, 0, bytes, i, VoteType.Length); i += VoteType.Length;
                if(VoteResult == null) { Console.WriteLine("Warning: VoteResult is null, in " + this.GetType()); }
                bytes[i++] = (byte)VoteResult.Length;
                Buffer.BlockCopy(VoteResult, 0, bytes, i, VoteResult.Length); i += VoteResult.Length;
                ba = BitConverter.GetBytes(Majority);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(Quorum % 256);
                bytes[i++] = (byte)((Quorum >> 8) % 256);
                bytes[i++] = (byte)((Quorum >> 16) % 256);
                bytes[i++] = (byte)((Quorum >> 24) % 256);
                if(ProposalText == null) { Console.WriteLine("Warning: ProposalText is null, in " + this.GetType()); }
                bytes[i++] = (byte)(ProposalText.Length % 256);
                bytes[i++] = (byte)((ProposalText.Length >> 8) % 256);
                Buffer.BlockCopy(ProposalText, 0, bytes, i, ProposalText.Length); i += ProposalText.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HistoryItemData --");
                output.AppendLine(String.Format("VoteID: {0}", VoteID));
                Helpers.FieldToString(output, TerseDateID, "TerseDateID");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, StartDateTime, "StartDateTime");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, EndDateTime, "EndDateTime");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("VoteInitiator: {0}", VoteInitiator));
                Helpers.FieldToString(output, VoteType, "VoteType");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, VoteResult, "VoteResult");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Majority: {0}", Majority));
                output.AppendLine(String.Format("Quorum: {0}", Quorum));
                Helpers.FieldToString(output, ProposalText, "ProposalText");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupvotehistoryitemreply_voteitem")]
        public class VoteItemBlock
        {
            public LLUUID CandidateID;
            private byte[] _votecast;
            public byte[] VoteCast
            {
                get { return _votecast; }
                set
                {
                    if (value == null) { _votecast = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _votecast = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votecast, 0, value.Length); }
                }
            }
            public int NumVotes;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 20;
                    if (VoteCast != null) { length += 1 + VoteCast.Length; }
                    return length;
                }
            }

            public VoteItemBlock() { }
            public VoteItemBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    CandidateID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _votecast = new byte[length];
                    Buffer.BlockCopy(bytes, i, _votecast, 0, length); i += length;
                    NumVotes = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(CandidateID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(VoteCast == null) { Console.WriteLine("Warning: VoteCast is null, in " + this.GetType()); }
                bytes[i++] = (byte)VoteCast.Length;
                Buffer.BlockCopy(VoteCast, 0, bytes, i, VoteCast.Length); i += VoteCast.Length;
                bytes[i++] = (byte)(NumVotes % 256);
                bytes[i++] = (byte)((NumVotes >> 8) % 256);
                bytes[i++] = (byte)((NumVotes >> 16) % 256);
                bytes[i++] = (byte)((NumVotes >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- VoteItem --");
                output.AppendLine(String.Format("CandidateID: {0}", CandidateID));
                Helpers.FieldToString(output, VoteCast, "VoteCast");
                output.Append(Environment.NewLine);
                output.Append(String.Format("NumVotes: {0}", NumVotes));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupVoteHistoryItemReply; } }
        public AgentDataBlock AgentData;
        public TransactionDataBlock TransactionData;
        public HistoryItemDataBlock HistoryItemData;
        public VoteItemBlock[] VoteItem;

        public GroupVoteHistoryItemReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 362;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TransactionData = new TransactionDataBlock();
            HistoryItemData = new HistoryItemDataBlock();
            VoteItem = new VoteItemBlock[0];
        }

        public GroupVoteHistoryItemReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            HistoryItemData = new HistoryItemDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            VoteItem = new VoteItemBlock[count];
            for (int j = 0; j < count; j++)
            { VoteItem[j] = new VoteItemBlock(bytes, ref i); }
        }

        public GroupVoteHistoryItemReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TransactionData = new TransactionDataBlock(bytes, ref i);
            HistoryItemData = new HistoryItemDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            VoteItem = new VoteItemBlock[count];
            for (int j = 0; j < count; j++)
            { VoteItem[j] = new VoteItemBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += TransactionData.Length;            length += HistoryItemData.Length;;
            length++;
            for (int j = 0; j < VoteItem.Length; j++) { length += VoteItem[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TransactionData.ToBytes(bytes, ref i);
            HistoryItemData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)VoteItem.Length;
            for (int j = 0; j < VoteItem.Length; j++) { VoteItem[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupVoteHistoryItemReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TransactionData.ToString() + Environment.NewLine;
                output += HistoryItemData.ToString() + Environment.NewLine;
            for (int j = 0; j < VoteItem.Length; j++)
            {
                output += VoteItem[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class StartGroupProposalPacket : Packet
    {
        /// <exclude/>
        [XmlType("startgroupproposal_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("startgroupproposal_proposaldata")]
        public class ProposalDataBlock
        {
            public LLUUID GroupID;
            public int Quorum;
            public float Majority;
            public int Duration;
            private byte[] _proposaltext;
            public byte[] ProposalText
            {
                get { return _proposaltext; }
                set
                {
                    if (value == null) { _proposaltext = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _proposaltext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _proposaltext, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (ProposalText != null) { length += 1 + ProposalText.Length; }
                    return length;
                }
            }

            public ProposalDataBlock() { }
            public ProposalDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Quorum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Majority = BitConverter.ToSingle(bytes, i); i += 4;
                    Duration = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _proposaltext = new byte[length];
                    Buffer.BlockCopy(bytes, i, _proposaltext, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Quorum % 256);
                bytes[i++] = (byte)((Quorum >> 8) % 256);
                bytes[i++] = (byte)((Quorum >> 16) % 256);
                bytes[i++] = (byte)((Quorum >> 24) % 256);
                ba = BitConverter.GetBytes(Majority);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(Duration % 256);
                bytes[i++] = (byte)((Duration >> 8) % 256);
                bytes[i++] = (byte)((Duration >> 16) % 256);
                bytes[i++] = (byte)((Duration >> 24) % 256);
                if(ProposalText == null) { Console.WriteLine("Warning: ProposalText is null, in " + this.GetType()); }
                bytes[i++] = (byte)ProposalText.Length;
                Buffer.BlockCopy(ProposalText, 0, bytes, i, ProposalText.Length); i += ProposalText.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ProposalData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("Quorum: {0}", Quorum));
                output.AppendLine(String.Format("Majority: {0}", Majority));
                output.AppendLine(String.Format("Duration: {0}", Duration));
                Helpers.FieldToString(output, ProposalText, "ProposalText");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.StartGroupProposal; } }
        public AgentDataBlock AgentData;
        public ProposalDataBlock ProposalData;

        public StartGroupProposalPacket()
        {
            Header = new LowHeader();
            Header.ID = 363;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ProposalData = new ProposalDataBlock();
        }

        public StartGroupProposalPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ProposalData = new ProposalDataBlock(bytes, ref i);
        }

        public StartGroupProposalPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ProposalData = new ProposalDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ProposalData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ProposalData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- StartGroupProposal ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ProposalData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupProposalBallotPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupproposalballot_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupproposalballot_proposaldata")]
        public class ProposalDataBlock
        {
            public LLUUID ProposalID;
            public LLUUID GroupID;
            private byte[] _votecast;
            public byte[] VoteCast
            {
                get { return _votecast; }
                set
                {
                    if (value == null) { _votecast = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _votecast = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votecast, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 32;
                    if (VoteCast != null) { length += 1 + VoteCast.Length; }
                    return length;
                }
            }

            public ProposalDataBlock() { }
            public ProposalDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ProposalID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _votecast = new byte[length];
                    Buffer.BlockCopy(bytes, i, _votecast, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ProposalID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(VoteCast == null) { Console.WriteLine("Warning: VoteCast is null, in " + this.GetType()); }
                bytes[i++] = (byte)VoteCast.Length;
                Buffer.BlockCopy(VoteCast, 0, bytes, i, VoteCast.Length); i += VoteCast.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ProposalData --");
                output.AppendLine(String.Format("ProposalID: {0}", ProposalID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                Helpers.FieldToString(output, VoteCast, "VoteCast");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupProposalBallot; } }
        public AgentDataBlock AgentData;
        public ProposalDataBlock ProposalData;

        public GroupProposalBallotPacket()
        {
            Header = new LowHeader();
            Header.ID = 364;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ProposalData = new ProposalDataBlock();
        }

        public GroupProposalBallotPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ProposalData = new ProposalDataBlock(bytes, ref i);
        }

        public GroupProposalBallotPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ProposalData = new ProposalDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ProposalData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ProposalData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupProposalBallot ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ProposalData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupMembersRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupmembersrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupmembersrequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public LLUUID RequestID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("RequestID: {0}", RequestID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupMembersRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public GroupMembersRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 366;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public GroupMembersRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public GroupMembersRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupMembersRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupMembersReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("groupmembersreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupmembersreply_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public LLUUID RequestID;
            public int MemberCount;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                    MemberCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(MemberCount % 256);
                bytes[i++] = (byte)((MemberCount >> 8) % 256);
                bytes[i++] = (byte)((MemberCount >> 16) % 256);
                bytes[i++] = (byte)((MemberCount >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.Append(String.Format("MemberCount: {0}", MemberCount));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("groupmembersreply_memberdata")]
        public class MemberDataBlock
        {
            public LLUUID AgentID;
            public int Contribution;
            private byte[] _onlinestatus;
            public byte[] OnlineStatus
            {
                get { return _onlinestatus; }
                set
                {
                    if (value == null) { _onlinestatus = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _onlinestatus = new byte[value.Length]; Buffer.BlockCopy(value, 0, _onlinestatus, 0, value.Length); }
                }
            }
            public ulong AgentPowers;
            private byte[] _title;
            public byte[] Title
            {
                get { return _title; }
                set
                {
                    if (value == null) { _title = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
                }
            }
            public bool IsOwner;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 29;
                    if (OnlineStatus != null) { length += 1 + OnlineStatus.Length; }
                    if (Title != null) { length += 1 + Title.Length; }
                    return length;
                }
            }

            public MemberDataBlock() { }
            public MemberDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    Contribution = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _onlinestatus = new byte[length];
                    Buffer.BlockCopy(bytes, i, _onlinestatus, 0, length); i += length;
                    AgentPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    length = (ushort)bytes[i++];
                    _title = new byte[length];
                    Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
                    IsOwner = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Contribution % 256);
                bytes[i++] = (byte)((Contribution >> 8) % 256);
                bytes[i++] = (byte)((Contribution >> 16) % 256);
                bytes[i++] = (byte)((Contribution >> 24) % 256);
                if(OnlineStatus == null) { Console.WriteLine("Warning: OnlineStatus is null, in " + this.GetType()); }
                bytes[i++] = (byte)OnlineStatus.Length;
                Buffer.BlockCopy(OnlineStatus, 0, bytes, i, OnlineStatus.Length); i += OnlineStatus.Length;
                bytes[i++] = (byte)(AgentPowers % 256);
                bytes[i++] = (byte)((AgentPowers >> 8) % 256);
                bytes[i++] = (byte)((AgentPowers >> 16) % 256);
                bytes[i++] = (byte)((AgentPowers >> 24) % 256);
                bytes[i++] = (byte)((AgentPowers >> 32) % 256);
                bytes[i++] = (byte)((AgentPowers >> 40) % 256);
                bytes[i++] = (byte)((AgentPowers >> 48) % 256);
                bytes[i++] = (byte)((AgentPowers >> 56) % 256);
                if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
                bytes[i++] = (byte)Title.Length;
                Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
                bytes[i++] = (byte)((IsOwner) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MemberData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("Contribution: {0}", Contribution));
                Helpers.FieldToString(output, OnlineStatus, "OnlineStatus");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("AgentPowers: {0}", AgentPowers));
                Helpers.FieldToString(output, Title, "Title");
                output.Append(Environment.NewLine);
                output.Append(String.Format("IsOwner: {0}", IsOwner));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupMembersReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public MemberDataBlock[] MemberData;

        public GroupMembersReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 367;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            MemberData = new MemberDataBlock[0];
        }

        public GroupMembersReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            MemberData = new MemberDataBlock[count];
            for (int j = 0; j < count; j++)
            { MemberData[j] = new MemberDataBlock(bytes, ref i); }
        }

        public GroupMembersReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            MemberData = new MemberDataBlock[count];
            for (int j = 0; j < count; j++)
            { MemberData[j] = new MemberDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            length++;
            for (int j = 0; j < MemberData.Length; j++) { length += MemberData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)MemberData.Length;
            for (int j = 0; j < MemberData.Length; j++) { MemberData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupMembersReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            for (int j = 0; j < MemberData.Length; j++)
            {
                output += MemberData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ActivateGroupPacket : Packet
    {
        /// <exclude/>
        [XmlType("activategroup_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ActivateGroup; } }
        public AgentDataBlock AgentData;

        public ActivateGroupPacket()
        {
            Header = new LowHeader();
            Header.ID = 368;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ActivateGroupPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ActivateGroupPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ActivateGroup ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SetGroupContributionPacket : Packet
    {
        /// <exclude/>
        [XmlType("setgroupcontribution_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("setgroupcontribution_data")]
        public class DataBlock
        {
            public LLUUID GroupID;
            public int Contribution;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    Contribution = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Contribution % 256);
                bytes[i++] = (byte)((Contribution >> 8) % 256);
                bytes[i++] = (byte)((Contribution >> 16) % 256);
                bytes[i++] = (byte)((Contribution >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("Contribution: {0}", Contribution));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SetGroupContribution; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public SetGroupContributionPacket()
        {
            Header = new LowHeader();
            Header.ID = 369;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public SetGroupContributionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public SetGroupContributionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SetGroupContribution ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SetGroupAcceptNoticesPacket : Packet
    {
        /// <exclude/>
        [XmlType("setgroupacceptnotices_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("setgroupacceptnotices_data")]
        public class DataBlock
        {
            public LLUUID GroupID;
            public bool AcceptNotices;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("AcceptNotices: {0}", AcceptNotices));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SetGroupAcceptNotices; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public SetGroupAcceptNoticesPacket()
        {
            Header = new LowHeader();
            Header.ID = 370;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public SetGroupAcceptNoticesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public SetGroupAcceptNoticesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SetGroupAcceptNotices ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupRoleDataRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouproledatarequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouproledatarequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public LLUUID RequestID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("RequestID: {0}", RequestID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupRoleDataRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public GroupRoleDataRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 371;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public GroupRoleDataRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public GroupRoleDataRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupRoleDataRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupRoleDataReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouproledatareply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouproledatareply_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public LLUUID RequestID;
            public int RoleCount;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                    RoleCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(RoleCount % 256);
                bytes[i++] = (byte)((RoleCount >> 8) % 256);
                bytes[i++] = (byte)((RoleCount >> 16) % 256);
                bytes[i++] = (byte)((RoleCount >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.Append(String.Format("RoleCount: {0}", RoleCount));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouproledatareply_roledata")]
        public class RoleDataBlock
        {
            public LLUUID RoleID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _title;
            public byte[] Title
            {
                get { return _title; }
                set
                {
                    if (value == null) { _title = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            public ulong Powers;
            public uint Members;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Title != null) { length += 1 + Title.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public RoleDataBlock() { }
            public RoleDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RoleID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _title = new byte[length];
                    Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    Powers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Members = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
                bytes[i++] = (byte)Title.Length;
                Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                bytes[i++] = (byte)(Powers % 256);
                bytes[i++] = (byte)((Powers >> 8) % 256);
                bytes[i++] = (byte)((Powers >> 16) % 256);
                bytes[i++] = (byte)((Powers >> 24) % 256);
                bytes[i++] = (byte)((Powers >> 32) % 256);
                bytes[i++] = (byte)((Powers >> 40) % 256);
                bytes[i++] = (byte)((Powers >> 48) % 256);
                bytes[i++] = (byte)((Powers >> 56) % 256);
                bytes[i++] = (byte)(Members % 256);
                bytes[i++] = (byte)((Members >> 8) % 256);
                bytes[i++] = (byte)((Members >> 16) % 256);
                bytes[i++] = (byte)((Members >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RoleData --");
                output.AppendLine(String.Format("RoleID: {0}", RoleID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Title, "Title");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Powers: {0}", Powers));
                output.Append(String.Format("Members: {0}", Members));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupRoleDataReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;
        public RoleDataBlock[] RoleData;

        public GroupRoleDataReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 372;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
            RoleData = new RoleDataBlock[0];
        }

        public GroupRoleDataReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RoleData = new RoleDataBlock[count];
            for (int j = 0; j < count; j++)
            { RoleData[j] = new RoleDataBlock(bytes, ref i); }
        }

        public GroupRoleDataReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RoleData = new RoleDataBlock[count];
            for (int j = 0; j < count; j++)
            { RoleData[j] = new RoleDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            length++;
            for (int j = 0; j < RoleData.Length; j++) { length += RoleData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)RoleData.Length;
            for (int j = 0; j < RoleData.Length; j++) { RoleData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupRoleDataReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            for (int j = 0; j < RoleData.Length; j++)
            {
                output += RoleData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupRoleMembersRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouprolemembersrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouprolemembersrequest_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public LLUUID RequestID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("RequestID: {0}", RequestID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupRoleMembersRequest; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock GroupData;

        public GroupRoleMembersRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 373;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock();
        }

        public GroupRoleMembersRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public GroupRoleMembersRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            GroupData = new GroupDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += GroupData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            GroupData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupRoleMembersRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += GroupData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupRoleMembersReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouprolemembersreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;
            public LLUUID RequestID;
            public uint TotalPairs;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 52;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                    TotalPairs = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(TotalPairs % 256);
                bytes[i++] = (byte)((TotalPairs >> 8) % 256);
                bytes[i++] = (byte)((TotalPairs >> 16) % 256);
                bytes[i++] = (byte)((TotalPairs >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.Append(String.Format("TotalPairs: {0}", TotalPairs));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouprolemembersreply_memberdata")]
        public class MemberDataBlock
        {
            public LLUUID RoleID;
            public LLUUID MemberID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public MemberDataBlock() { }
            public MemberDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RoleID = new LLUUID(bytes, i); i += 16;
                    MemberID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(MemberID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MemberData --");
                output.AppendLine(String.Format("RoleID: {0}", RoleID));
                output.Append(String.Format("MemberID: {0}", MemberID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupRoleMembersReply; } }
        public AgentDataBlock AgentData;
        public MemberDataBlock[] MemberData;

        public GroupRoleMembersReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 374;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            MemberData = new MemberDataBlock[0];
        }

        public GroupRoleMembersReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            MemberData = new MemberDataBlock[count];
            for (int j = 0; j < count; j++)
            { MemberData[j] = new MemberDataBlock(bytes, ref i); }
        }

        public GroupRoleMembersReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            MemberData = new MemberDataBlock[count];
            for (int j = 0; j < count; j++)
            { MemberData[j] = new MemberDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < MemberData.Length; j++) { length += MemberData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)MemberData.Length;
            for (int j = 0; j < MemberData.Length; j++) { MemberData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupRoleMembersReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < MemberData.Length; j++)
            {
                output += MemberData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupTitlesRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouptitlesrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;
            public LLUUID RequestID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 64;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("RequestID: {0}", RequestID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupTitlesRequest; } }
        public AgentDataBlock AgentData;

        public GroupTitlesRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 375;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public GroupTitlesRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public GroupTitlesRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupTitlesRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupTitlesReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("grouptitlesreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;
            public LLUUID RequestID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    RequestID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("RequestID: {0}", RequestID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouptitlesreply_groupdata")]
        public class GroupDataBlock
        {
            private byte[] _title;
            public byte[] Title
            {
                get { return _title; }
                set
                {
                    if (value == null) { _title = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
                }
            }
            public LLUUID RoleID;
            public bool Selected;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 17;
                    if (Title != null) { length += 1 + Title.Length; }
                    return length;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _title = new byte[length];
                    Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
                    RoleID = new LLUUID(bytes, i); i += 16;
                    Selected = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
                bytes[i++] = (byte)Title.Length;
                Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
                Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((Selected) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                Helpers.FieldToString(output, Title, "Title");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("RoleID: {0}", RoleID));
                output.Append(String.Format("Selected: {0}", Selected));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupTitlesReply; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock[] GroupData;

        public GroupTitlesReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 376;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock[0];
        }

        public GroupTitlesReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
        }

        public GroupTitlesReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)GroupData.Length;
            for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupTitlesReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < GroupData.Length; j++)
            {
                output += GroupData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class GroupTitleUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("grouptitleupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;
            public LLUUID TitleRoleID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 64;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    TitleRoleID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(TitleRoleID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.Append(String.Format("TitleRoleID: {0}", TitleRoleID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupTitleUpdate; } }
        public AgentDataBlock AgentData;

        public GroupTitleUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 377;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public GroupTitleUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public GroupTitleUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupTitleUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupRoleUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("grouproleupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("grouproleupdate_roledata")]
        public class RoleDataBlock
        {
            public LLUUID RoleID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            private byte[] _title;
            public byte[] Title
            {
                get { return _title; }
                set
                {
                    if (value == null) { _title = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
                }
            }
            public ulong Powers;
            public byte UpdateType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 25;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    if (Title != null) { length += 1 + Title.Length; }
                    return length;
                }
            }

            public RoleDataBlock() { }
            public RoleDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RoleID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _title = new byte[length];
                    Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
                    Powers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    UpdateType = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
                bytes[i++] = (byte)Title.Length;
                Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
                bytes[i++] = (byte)(Powers % 256);
                bytes[i++] = (byte)((Powers >> 8) % 256);
                bytes[i++] = (byte)((Powers >> 16) % 256);
                bytes[i++] = (byte)((Powers >> 24) % 256);
                bytes[i++] = (byte)((Powers >> 32) % 256);
                bytes[i++] = (byte)((Powers >> 40) % 256);
                bytes[i++] = (byte)((Powers >> 48) % 256);
                bytes[i++] = (byte)((Powers >> 56) % 256);
                bytes[i++] = UpdateType;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RoleData --");
                output.AppendLine(String.Format("RoleID: {0}", RoleID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Title, "Title");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Powers: {0}", Powers));
                output.Append(String.Format("UpdateType: {0}", UpdateType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupRoleUpdate; } }
        public AgentDataBlock AgentData;
        public RoleDataBlock[] RoleData;

        public GroupRoleUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 378;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RoleData = new RoleDataBlock[0];
        }

        public GroupRoleUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RoleData = new RoleDataBlock[count];
            for (int j = 0; j < count; j++)
            { RoleData[j] = new RoleDataBlock(bytes, ref i); }
        }

        public GroupRoleUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RoleData = new RoleDataBlock[count];
            for (int j = 0; j < count; j++)
            { RoleData[j] = new RoleDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < RoleData.Length; j++) { length += RoleData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)RoleData.Length;
            for (int j = 0; j < RoleData.Length; j++) { RoleData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupRoleUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < RoleData.Length; j++)
            {
                output += RoleData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class LiveHelpGroupRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("livehelpgrouprequest_requestdata")]
        public class RequestDataBlock
        {
            public LLUUID RequestID;
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public RequestDataBlock() { }
            public RequestDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LiveHelpGroupRequest; } }
        public RequestDataBlock RequestData;

        public LiveHelpGroupRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 379;
            Header.Reliable = true;
            RequestData = new RequestDataBlock();
        }

        public LiveHelpGroupRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            RequestData = new RequestDataBlock(bytes, ref i);
        }

        public LiveHelpGroupRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RequestData = new RequestDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += RequestData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RequestData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LiveHelpGroupRequest ---" + Environment.NewLine;
                output += RequestData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LiveHelpGroupReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("livehelpgroupreply_replydata")]
        public class ReplyDataBlock
        {
            public LLUUID RequestID;
            public LLUUID GroupID;
            private byte[] _selection;
            public byte[] Selection
            {
                get { return _selection; }
                set
                {
                    if (value == null) { _selection = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _selection = new byte[value.Length]; Buffer.BlockCopy(value, 0, _selection, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 32;
                    if (Selection != null) { length += 1 + Selection.Length; }
                    return length;
                }
            }

            public ReplyDataBlock() { }
            public ReplyDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RequestID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _selection = new byte[length];
                    Buffer.BlockCopy(bytes, i, _selection, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Selection == null) { Console.WriteLine("Warning: Selection is null, in " + this.GetType()); }
                bytes[i++] = (byte)Selection.Length;
                Buffer.BlockCopy(Selection, 0, bytes, i, Selection.Length); i += Selection.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ReplyData --");
                output.AppendLine(String.Format("RequestID: {0}", RequestID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                Helpers.FieldToString(output, Selection, "Selection");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LiveHelpGroupReply; } }
        public ReplyDataBlock ReplyData;

        public LiveHelpGroupReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 380;
            Header.Reliable = true;
            ReplyData = new ReplyDataBlock();
        }

        public LiveHelpGroupReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ReplyData = new ReplyDataBlock(bytes, ref i);
        }

        public LiveHelpGroupReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ReplyData = new ReplyDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ReplyData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ReplyData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LiveHelpGroupReply ---" + Environment.NewLine;
                output += ReplyData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentWearablesRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentwearablesrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentWearablesRequest; } }
        public AgentDataBlock AgentData;

        public AgentWearablesRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 381;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentWearablesRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentWearablesRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentWearablesRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentWearablesUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentwearablesupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint SerialNum;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SerialNum % 256);
                bytes[i++] = (byte)((SerialNum >> 8) % 256);
                bytes[i++] = (byte)((SerialNum >> 16) % 256);
                bytes[i++] = (byte)((SerialNum >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("SerialNum: {0}", SerialNum));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentwearablesupdate_wearabledata")]
        public class WearableDataBlock
        {
            public LLUUID ItemID;
            public LLUUID AssetID;
            public byte WearableType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 33;
                }
            }

            public WearableDataBlock() { }
            public WearableDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    WearableType = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = WearableType;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- WearableData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.Append(String.Format("WearableType: {0}", WearableType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentWearablesUpdate; } }
        public AgentDataBlock AgentData;
        public WearableDataBlock[] WearableData;

        public AgentWearablesUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 382;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            WearableData = new WearableDataBlock[0];
        }

        public AgentWearablesUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public AgentWearablesUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)WearableData.Length;
            for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentWearablesUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < WearableData.Length; j++)
            {
                output += WearableData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentIsNowWearingPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentisnowwearing_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentisnowwearing_wearabledata")]
        public class WearableDataBlock
        {
            public LLUUID ItemID;
            public byte WearableType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public WearableDataBlock() { }
            public WearableDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    WearableType = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = WearableType;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- WearableData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.Append(String.Format("WearableType: {0}", WearableType));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentIsNowWearing; } }
        public AgentDataBlock AgentData;
        public WearableDataBlock[] WearableData;

        public AgentIsNowWearingPacket()
        {
            Header = new LowHeader();
            Header.ID = 383;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            WearableData = new WearableDataBlock[0];
        }

        public AgentIsNowWearingPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public AgentIsNowWearingPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)WearableData.Length;
            for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentIsNowWearing ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < WearableData.Length; j++)
            {
                output += WearableData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentCachedTexturePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentcachedtexture_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public int SerialNum;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    SerialNum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SerialNum % 256);
                bytes[i++] = (byte)((SerialNum >> 8) % 256);
                bytes[i++] = (byte)((SerialNum >> 16) % 256);
                bytes[i++] = (byte)((SerialNum >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("SerialNum: {0}", SerialNum));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentcachedtexture_wearabledata")]
        public class WearableDataBlock
        {
            public LLUUID ID;
            public byte TextureIndex;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public WearableDataBlock() { }
            public WearableDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    TextureIndex = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = TextureIndex;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- WearableData --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.Append(String.Format("TextureIndex: {0}", TextureIndex));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentCachedTexture; } }
        public AgentDataBlock AgentData;
        public WearableDataBlock[] WearableData;

        public AgentCachedTexturePacket()
        {
            Header = new LowHeader();
            Header.ID = 384;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            WearableData = new WearableDataBlock[0];
        }

        public AgentCachedTexturePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public AgentCachedTexturePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)WearableData.Length;
            for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentCachedTexture ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < WearableData.Length; j++)
            {
                output += WearableData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentCachedTextureResponsePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentcachedtextureresponse_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public int SerialNum;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 36;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    SerialNum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(SerialNum % 256);
                bytes[i++] = (byte)((SerialNum >> 8) % 256);
                bytes[i++] = (byte)((SerialNum >> 16) % 256);
                bytes[i++] = (byte)((SerialNum >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("SerialNum: {0}", SerialNum));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentcachedtextureresponse_wearabledata")]
        public class WearableDataBlock
        {
            public LLUUID TextureID;
            public byte TextureIndex;
            private byte[] _hostname;
            public byte[] HostName
            {
                get { return _hostname; }
                set
                {
                    if (value == null) { _hostname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _hostname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _hostname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 17;
                    if (HostName != null) { length += 1 + HostName.Length; }
                    return length;
                }
            }

            public WearableDataBlock() { }
            public WearableDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TextureID = new LLUUID(bytes, i); i += 16;
                    TextureIndex = (byte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _hostname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _hostname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TextureID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = TextureIndex;
                if(HostName == null) { Console.WriteLine("Warning: HostName is null, in " + this.GetType()); }
                bytes[i++] = (byte)HostName.Length;
                Buffer.BlockCopy(HostName, 0, bytes, i, HostName.Length); i += HostName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- WearableData --");
                output.AppendLine(String.Format("TextureID: {0}", TextureID));
                output.AppendLine(String.Format("TextureIndex: {0}", TextureIndex));
                Helpers.FieldToString(output, HostName, "HostName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentCachedTextureResponse; } }
        public AgentDataBlock AgentData;
        public WearableDataBlock[] WearableData;

        public AgentCachedTextureResponsePacket()
        {
            Header = new LowHeader();
            Header.ID = 385;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            WearableData = new WearableDataBlock[0];
        }

        public AgentCachedTextureResponsePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public AgentCachedTextureResponsePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            WearableData = new WearableDataBlock[count];
            for (int j = 0; j < count; j++)
            { WearableData[j] = new WearableDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)WearableData.Length;
            for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentCachedTextureResponse ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < WearableData.Length; j++)
            {
                output += WearableData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentDataUpdateRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentdataupdaterequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentDataUpdateRequest; } }
        public AgentDataBlock AgentData;

        public AgentDataUpdateRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 386;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentDataUpdateRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentDataUpdateRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentDataUpdateRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentDataUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentdataupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            private byte[] _firstname;
            public byte[] FirstName
            {
                get { return _firstname; }
                set
                {
                    if (value == null) { _firstname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
                }
            }
            private byte[] _lastname;
            public byte[] LastName
            {
                get { return _lastname; }
                set
                {
                    if (value == null) { _lastname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
                }
            }
            private byte[] _grouptitle;
            public byte[] GroupTitle
            {
                get { return _grouptitle; }
                set
                {
                    if (value == null) { _grouptitle = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _grouptitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _grouptitle, 0, value.Length); }
                }
            }
            public LLUUID ActiveGroupID;
            public ulong GroupPowers;
            private byte[] _groupname;
            public byte[] GroupName
            {
                get { return _groupname; }
                set
                {
                    if (value == null) { _groupname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 40;
                    if (FirstName != null) { length += 1 + FirstName.Length; }
                    if (LastName != null) { length += 1 + LastName.Length; }
                    if (GroupTitle != null) { length += 1 + GroupTitle.Length; }
                    if (GroupName != null) { length += 1 + GroupName.Length; }
                    return length;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _firstname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _lastname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _grouptitle = new byte[length];
                    Buffer.BlockCopy(bytes, i, _grouptitle, 0, length); i += length;
                    ActiveGroupID = new LLUUID(bytes, i); i += 16;
                    GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    length = (ushort)bytes[i++];
                    _groupname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
                bytes[i++] = (byte)FirstName.Length;
                Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
                if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
                bytes[i++] = (byte)LastName.Length;
                Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
                if(GroupTitle == null) { Console.WriteLine("Warning: GroupTitle is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupTitle.Length;
                Buffer.BlockCopy(GroupTitle, 0, bytes, i, GroupTitle.Length); i += GroupTitle.Length;
                Buffer.BlockCopy(ActiveGroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(GroupPowers % 256);
                bytes[i++] = (byte)((GroupPowers >> 8) % 256);
                bytes[i++] = (byte)((GroupPowers >> 16) % 256);
                bytes[i++] = (byte)((GroupPowers >> 24) % 256);
                bytes[i++] = (byte)((GroupPowers >> 32) % 256);
                bytes[i++] = (byte)((GroupPowers >> 40) % 256);
                bytes[i++] = (byte)((GroupPowers >> 48) % 256);
                bytes[i++] = (byte)((GroupPowers >> 56) % 256);
                if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupName.Length;
                Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                Helpers.FieldToString(output, FirstName, "FirstName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, LastName, "LastName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, GroupTitle, "GroupTitle");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ActiveGroupID: {0}", ActiveGroupID));
                output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
                Helpers.FieldToString(output, GroupName, "GroupName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentDataUpdate; } }
        public AgentDataBlock AgentData;

        public AgentDataUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 387;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentDataUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentDataUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentDataUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class GroupDataUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("groupdataupdate_agentgroupdata")]
        public class AgentGroupDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;
            public ulong AgentPowers;
            private byte[] _grouptitle;
            public byte[] GroupTitle
            {
                get { return _grouptitle; }
                set
                {
                    if (value == null) { _grouptitle = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _grouptitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _grouptitle, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 40;
                    if (GroupTitle != null) { length += 1 + GroupTitle.Length; }
                    return length;
                }
            }

            public AgentGroupDataBlock() { }
            public AgentGroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    AgentPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    length = (ushort)bytes[i++];
                    _grouptitle = new byte[length];
                    Buffer.BlockCopy(bytes, i, _grouptitle, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(AgentPowers % 256);
                bytes[i++] = (byte)((AgentPowers >> 8) % 256);
                bytes[i++] = (byte)((AgentPowers >> 16) % 256);
                bytes[i++] = (byte)((AgentPowers >> 24) % 256);
                bytes[i++] = (byte)((AgentPowers >> 32) % 256);
                bytes[i++] = (byte)((AgentPowers >> 40) % 256);
                bytes[i++] = (byte)((AgentPowers >> 48) % 256);
                bytes[i++] = (byte)((AgentPowers >> 56) % 256);
                if(GroupTitle == null) { Console.WriteLine("Warning: GroupTitle is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupTitle.Length;
                Buffer.BlockCopy(GroupTitle, 0, bytes, i, GroupTitle.Length); i += GroupTitle.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentGroupData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("AgentPowers: {0}", AgentPowers));
                Helpers.FieldToString(output, GroupTitle, "GroupTitle");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.GroupDataUpdate; } }
        public AgentGroupDataBlock[] AgentGroupData;

        public GroupDataUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 388;
            Header.Reliable = true;
            AgentGroupData = new AgentGroupDataBlock[0];
        }

        public GroupDataUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            AgentGroupData = new AgentGroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { AgentGroupData[j] = new AgentGroupDataBlock(bytes, ref i); }
        }

        public GroupDataUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            AgentGroupData = new AgentGroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { AgentGroupData[j] = new AgentGroupDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < AgentGroupData.Length; j++) { length += AgentGroupData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)AgentGroupData.Length;
            for (int j = 0; j < AgentGroupData.Length; j++) { AgentGroupData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- GroupDataUpdate ---" + Environment.NewLine;
            for (int j = 0; j < AgentGroupData.Length; j++)
            {
                output += AgentGroupData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentGroupDataUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentgroupdataupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentgroupdataupdate_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public ulong GroupPowers;
            public bool AcceptNotices;
            public LLUUID GroupInsigniaID;
            public int Contribution;
            private byte[] _groupname;
            public byte[] GroupName
            {
                get { return _groupname; }
                set
                {
                    if (value == null) { _groupname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 45;
                    if (GroupName != null) { length += 1 + GroupName.Length; }
                    return length;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    GroupInsigniaID = new LLUUID(bytes, i); i += 16;
                    Contribution = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _groupname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(GroupPowers % 256);
                bytes[i++] = (byte)((GroupPowers >> 8) % 256);
                bytes[i++] = (byte)((GroupPowers >> 16) % 256);
                bytes[i++] = (byte)((GroupPowers >> 24) % 256);
                bytes[i++] = (byte)((GroupPowers >> 32) % 256);
                bytes[i++] = (byte)((GroupPowers >> 40) % 256);
                bytes[i++] = (byte)((GroupPowers >> 48) % 256);
                bytes[i++] = (byte)((GroupPowers >> 56) % 256);
                bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
                Buffer.BlockCopy(GroupInsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Contribution % 256);
                bytes[i++] = (byte)((Contribution >> 8) % 256);
                bytes[i++] = (byte)((Contribution >> 16) % 256);
                bytes[i++] = (byte)((Contribution >> 24) % 256);
                if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
                bytes[i++] = (byte)GroupName.Length;
                Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
                output.AppendLine(String.Format("AcceptNotices: {0}", AcceptNotices));
                output.AppendLine(String.Format("GroupInsigniaID: {0}", GroupInsigniaID));
                output.AppendLine(String.Format("Contribution: {0}", Contribution));
                Helpers.FieldToString(output, GroupName, "GroupName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentGroupDataUpdate; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock[] GroupData;

        public AgentGroupDataUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 389;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock[0];
        }

        public AgentGroupDataUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
        }

        public AgentGroupDataUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)GroupData.Length;
            for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentGroupDataUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < GroupData.Length; j++)
            {
                output += GroupData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentDropGroupPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentdropgroup_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentDropGroup; } }
        public AgentDataBlock AgentData;

        public AgentDropGroupPacket()
        {
            Header = new LowHeader();
            Header.ID = 390;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentDropGroupPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentDropGroupPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentDropGroup ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateTrustedCircuitPacket : Packet
    {
        /// <exclude/>
        [XmlType("createtrustedcircuit_datablock")]
        public class DataBlockBlock
        {
            public LLUUID EndPointID;
            public byte[] Digest;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EndPointID = new LLUUID(bytes, i); i += 16;
                    Digest = new byte[32];
                    Buffer.BlockCopy(bytes, i, Digest, 0, 32); i += 32;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(EndPointID.GetBytes(), 0, bytes, i, 16); i += 16;
                                Buffer.BlockCopy(Digest, 0, bytes, i, 32);i += 32;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                output.AppendLine(String.Format("EndPointID: {0}", EndPointID));
                Helpers.FieldToString(output, Digest, "Digest");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateTrustedCircuit; } }
        public DataBlockBlock DataBlock;

        public CreateTrustedCircuitPacket()
        {
            Header = new LowHeader();
            Header.ID = 392;
            Header.Reliable = true;
            DataBlock = new DataBlockBlock();
        }

        public CreateTrustedCircuitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public CreateTrustedCircuitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateTrustedCircuit ---" + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class DenyTrustedCircuitPacket : Packet
    {
        /// <exclude/>
        [XmlType("denytrustedcircuit_datablock")]
        public class DataBlockBlock
        {
            public LLUUID EndPointID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    EndPointID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(EndPointID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                output.Append(String.Format("EndPointID: {0}", EndPointID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DenyTrustedCircuit; } }
        public DataBlockBlock DataBlock;

        public DenyTrustedCircuitPacket()
        {
            Header = new LowHeader();
            Header.ID = 393;
            Header.Reliable = true;
            DataBlock = new DataBlockBlock();
        }

        public DenyTrustedCircuitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public DenyTrustedCircuitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DenyTrustedCircuit ---" + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RequestTrustedCircuitPacket : Packet
    {
        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestTrustedCircuit; } }

        public RequestTrustedCircuitPacket()
        {
            Header = new LowHeader();
            Header.ID = 394;
            Header.Reliable = true;
        }

        public RequestTrustedCircuitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
        }

        public RequestTrustedCircuitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestTrustedCircuit ---" + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RezSingleAttachmentFromInvPacket : Packet
    {
        /// <exclude/>
        [XmlType("rezsingleattachmentfrominv_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezsingleattachmentfrominv_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ItemID;
            public LLUUID OwnerID;
            public byte AttachmentPt;
            public uint ItemFlags;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 49;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    AttachmentPt = (byte)bytes[i++];
                    ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = AttachmentPt;
                bytes[i++] = (byte)(ItemFlags % 256);
                bytes[i++] = (byte)((ItemFlags >> 8) % 256);
                bytes[i++] = (byte)((ItemFlags >> 16) % 256);
                bytes[i++] = (byte)((ItemFlags >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("AttachmentPt: {0}", AttachmentPt));
                output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RezSingleAttachmentFromInv; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public RezSingleAttachmentFromInvPacket()
        {
            Header = new LowHeader();
            Header.ID = 395;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public RezSingleAttachmentFromInvPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public RezSingleAttachmentFromInvPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RezSingleAttachmentFromInv ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RezMultipleAttachmentsFromInvPacket : Packet
    {
        /// <exclude/>
        [XmlType("rezmultipleattachmentsfrominv_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezmultipleattachmentsfrominv_headerdata")]
        public class HeaderDataBlock
        {
            public LLUUID CompoundMsgID;
            public byte TotalObjects;
            public bool FirstDetachAll;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 18;
                }
            }

            public HeaderDataBlock() { }
            public HeaderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    CompoundMsgID = new LLUUID(bytes, i); i += 16;
                    TotalObjects = (byte)bytes[i++];
                    FirstDetachAll = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(CompoundMsgID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = TotalObjects;
                bytes[i++] = (byte)((FirstDetachAll) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HeaderData --");
                output.AppendLine(String.Format("CompoundMsgID: {0}", CompoundMsgID));
                output.AppendLine(String.Format("TotalObjects: {0}", TotalObjects));
                output.Append(String.Format("FirstDetachAll: {0}", FirstDetachAll));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("rezmultipleattachmentsfrominv_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ItemID;
            public LLUUID OwnerID;
            public byte AttachmentPt;
            public uint ItemFlags;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 49;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ItemID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    AttachmentPt = (byte)bytes[i++];
                    ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = AttachmentPt;
                bytes[i++] = (byte)(ItemFlags % 256);
                bytes[i++] = (byte)((ItemFlags >> 8) % 256);
                bytes[i++] = (byte)((ItemFlags >> 16) % 256);
                bytes[i++] = (byte)((ItemFlags >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("AttachmentPt: {0}", AttachmentPt));
                output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RezMultipleAttachmentsFromInv; } }
        public AgentDataBlock AgentData;
        public HeaderDataBlock HeaderData;
        public ObjectDataBlock[] ObjectData;

        public RezMultipleAttachmentsFromInvPacket()
        {
            Header = new LowHeader();
            Header.ID = 396;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            HeaderData = new HeaderDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public RezMultipleAttachmentsFromInvPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public RezMultipleAttachmentsFromInvPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += HeaderData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            HeaderData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RezMultipleAttachmentsFromInv ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += HeaderData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class DetachAttachmentIntoInvPacket : Packet
    {
        /// <exclude/>
        [XmlType("detachattachmentintoinv_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID AgentID;
            public LLUUID ItemID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    ItemID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("ItemID: {0}", ItemID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.DetachAttachmentIntoInv; } }
        public ObjectDataBlock ObjectData;

        public DetachAttachmentIntoInvPacket()
        {
            Header = new LowHeader();
            Header.ID = 397;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock();
        }

        public DetachAttachmentIntoInvPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public DetachAttachmentIntoInvPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- DetachAttachmentIntoInv ---" + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CreateNewOutfitAttachmentsPacket : Packet
    {
        /// <exclude/>
        [XmlType("createnewoutfitattachments_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("createnewoutfitattachments_headerdata")]
        public class HeaderDataBlock
        {
            public LLUUID NewFolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public HeaderDataBlock() { }
            public HeaderDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    NewFolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(NewFolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- HeaderData --");
                output.Append(String.Format("NewFolderID: {0}", NewFolderID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("createnewoutfitattachments_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID OldItemID;
            public LLUUID OldFolderID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    OldItemID = new LLUUID(bytes, i); i += 16;
                    OldFolderID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(OldItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OldFolderID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("OldItemID: {0}", OldItemID));
                output.Append(String.Format("OldFolderID: {0}", OldFolderID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CreateNewOutfitAttachments; } }
        public AgentDataBlock AgentData;
        public HeaderDataBlock HeaderData;
        public ObjectDataBlock[] ObjectData;

        public CreateNewOutfitAttachmentsPacket()
        {
            Header = new LowHeader();
            Header.ID = 398;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            HeaderData = new HeaderDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public CreateNewOutfitAttachmentsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public CreateNewOutfitAttachmentsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            HeaderData = new HeaderDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += HeaderData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            HeaderData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CreateNewOutfitAttachments ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += HeaderData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class UserInfoRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("userinforequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UserInfoRequest; } }
        public AgentDataBlock AgentData;

        public UserInfoRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 399;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public UserInfoRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public UserInfoRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UserInfoRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UserInfoReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("userinforeply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("userinforeply_userdata")]
        public class UserDataBlock
        {
            public bool IMViaEMail;
            private byte[] _directoryvisibility;
            public byte[] DirectoryVisibility
            {
                get { return _directoryvisibility; }
                set
                {
                    if (value == null) { _directoryvisibility = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _directoryvisibility = new byte[value.Length]; Buffer.BlockCopy(value, 0, _directoryvisibility, 0, value.Length); }
                }
            }
            private byte[] _email;
            public byte[] EMail
            {
                get { return _email; }
                set
                {
                    if (value == null) { _email = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _email = new byte[value.Length]; Buffer.BlockCopy(value, 0, _email, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 1;
                    if (DirectoryVisibility != null) { length += 1 + DirectoryVisibility.Length; }
                    if (EMail != null) { length += 2 + EMail.Length; }
                    return length;
                }
            }

            public UserDataBlock() { }
            public UserDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    IMViaEMail = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _directoryvisibility = new byte[length];
                    Buffer.BlockCopy(bytes, i, _directoryvisibility, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _email = new byte[length];
                    Buffer.BlockCopy(bytes, i, _email, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((IMViaEMail) ? 1 : 0);
                if(DirectoryVisibility == null) { Console.WriteLine("Warning: DirectoryVisibility is null, in " + this.GetType()); }
                bytes[i++] = (byte)DirectoryVisibility.Length;
                Buffer.BlockCopy(DirectoryVisibility, 0, bytes, i, DirectoryVisibility.Length); i += DirectoryVisibility.Length;
                if(EMail == null) { Console.WriteLine("Warning: EMail is null, in " + this.GetType()); }
                bytes[i++] = (byte)(EMail.Length % 256);
                bytes[i++] = (byte)((EMail.Length >> 8) % 256);
                Buffer.BlockCopy(EMail, 0, bytes, i, EMail.Length); i += EMail.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UserData --");
                output.AppendLine(String.Format("IMViaEMail: {0}", IMViaEMail));
                Helpers.FieldToString(output, DirectoryVisibility, "DirectoryVisibility");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, EMail, "EMail");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UserInfoReply; } }
        public AgentDataBlock AgentData;
        public UserDataBlock UserData;

        public UserInfoReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 400;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            UserData = new UserDataBlock();
        }

        public UserInfoReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            UserData = new UserDataBlock(bytes, ref i);
        }

        public UserInfoReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            UserData = new UserDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += UserData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            UserData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UserInfoReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += UserData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class UpdateUserInfoPacket : Packet
    {
        /// <exclude/>
        [XmlType("updateuserinfo_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("updateuserinfo_userdata")]
        public class UserDataBlock
        {
            public bool IMViaEMail;
            private byte[] _directoryvisibility;
            public byte[] DirectoryVisibility
            {
                get { return _directoryvisibility; }
                set
                {
                    if (value == null) { _directoryvisibility = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _directoryvisibility = new byte[value.Length]; Buffer.BlockCopy(value, 0, _directoryvisibility, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 1;
                    if (DirectoryVisibility != null) { length += 1 + DirectoryVisibility.Length; }
                    return length;
                }
            }

            public UserDataBlock() { }
            public UserDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    IMViaEMail = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    length = (ushort)bytes[i++];
                    _directoryvisibility = new byte[length];
                    Buffer.BlockCopy(bytes, i, _directoryvisibility, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((IMViaEMail) ? 1 : 0);
                if(DirectoryVisibility == null) { Console.WriteLine("Warning: DirectoryVisibility is null, in " + this.GetType()); }
                bytes[i++] = (byte)DirectoryVisibility.Length;
                Buffer.BlockCopy(DirectoryVisibility, 0, bytes, i, DirectoryVisibility.Length); i += DirectoryVisibility.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- UserData --");
                output.AppendLine(String.Format("IMViaEMail: {0}", IMViaEMail));
                Helpers.FieldToString(output, DirectoryVisibility, "DirectoryVisibility");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.UpdateUserInfo; } }
        public AgentDataBlock AgentData;
        public UserDataBlock UserData;

        public UpdateUserInfoPacket()
        {
            Header = new LowHeader();
            Header.ID = 401;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            UserData = new UserDataBlock();
        }

        public UpdateUserInfoPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            UserData = new UserDataBlock(bytes, ref i);
        }

        public UpdateUserInfoPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            UserData = new UserDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += UserData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            UserData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- UpdateUserInfo ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += UserData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class InitiateDownloadPacket : Packet
    {
        /// <exclude/>
        [XmlType("initiatedownload_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("initiatedownload_filedata")]
        public class FileDataBlock
        {
            private byte[] _simfilename;
            public byte[] SimFilename
            {
                get { return _simfilename; }
                set
                {
                    if (value == null) { _simfilename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _simfilename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simfilename, 0, value.Length); }
                }
            }
            private byte[] _viewerfilename;
            public byte[] ViewerFilename
            {
                get { return _viewerfilename; }
                set
                {
                    if (value == null) { _viewerfilename = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _viewerfilename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _viewerfilename, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (SimFilename != null) { length += 1 + SimFilename.Length; }
                    if (ViewerFilename != null) { length += 1 + ViewerFilename.Length; }
                    return length;
                }
            }

            public FileDataBlock() { }
            public FileDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _simfilename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _simfilename, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _viewerfilename = new byte[length];
                    Buffer.BlockCopy(bytes, i, _viewerfilename, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(SimFilename == null) { Console.WriteLine("Warning: SimFilename is null, in " + this.GetType()); }
                bytes[i++] = (byte)SimFilename.Length;
                Buffer.BlockCopy(SimFilename, 0, bytes, i, SimFilename.Length); i += SimFilename.Length;
                if(ViewerFilename == null) { Console.WriteLine("Warning: ViewerFilename is null, in " + this.GetType()); }
                bytes[i++] = (byte)ViewerFilename.Length;
                Buffer.BlockCopy(ViewerFilename, 0, bytes, i, ViewerFilename.Length); i += ViewerFilename.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- FileData --");
                Helpers.FieldToString(output, SimFilename, "SimFilename");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, ViewerFilename, "ViewerFilename");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.InitiateDownload; } }
        public AgentDataBlock AgentData;
        public FileDataBlock FileData;

        public InitiateDownloadPacket()
        {
            Header = new LowHeader();
            Header.ID = 403;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            FileData = new FileDataBlock();
        }

        public InitiateDownloadPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            FileData = new FileDataBlock(bytes, ref i);
        }

        public InitiateDownloadPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            FileData = new FileDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += FileData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            FileData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- InitiateDownload ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += FileData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SystemMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("systemmessage_methoddata")]
        public class MethodDataBlock
        {
            private byte[] _method;
            public byte[] Method
            {
                get { return _method; }
                set
                {
                    if (value == null) { _method = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
                }
            }
            public LLUUID Invoice;
            public byte[] Digest;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 48;
                    if (Method != null) { length += 1 + Method.Length; }
                    return length;
                }
            }

            public MethodDataBlock() { }
            public MethodDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _method = new byte[length];
                    Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
                    Invoice = new LLUUID(bytes, i); i += 16;
                    Digest = new byte[32];
                    Buffer.BlockCopy(bytes, i, Digest, 0, 32); i += 32;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
                bytes[i++] = (byte)Method.Length;
                Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
                Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
                                Buffer.BlockCopy(Digest, 0, bytes, i, 32);i += 32;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- MethodData --");
                Helpers.FieldToString(output, Method, "Method");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Invoice: {0}", Invoice));
                Helpers.FieldToString(output, Digest, "Digest");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("systemmessage_paramlist")]
        public class ParamListBlock
        {
            private byte[] _parameter;
            public byte[] Parameter
            {
                get { return _parameter; }
                set
                {
                    if (value == null) { _parameter = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Parameter != null) { length += 1 + Parameter.Length; }
                    return length;
                }
            }

            public ParamListBlock() { }
            public ParamListBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _parameter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
                bytes[i++] = (byte)Parameter.Length;
                Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParamList --");
                Helpers.FieldToString(output, Parameter, "Parameter");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SystemMessage; } }
        public MethodDataBlock MethodData;
        public ParamListBlock[] ParamList;

        public SystemMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 404;
            Header.Reliable = true;
            MethodData = new MethodDataBlock();
            ParamList = new ParamListBlock[0];
        }

        public SystemMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public SystemMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            MethodData = new MethodDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ParamList = new ParamListBlock[count];
            for (int j = 0; j < count; j++)
            { ParamList[j] = new ParamListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += MethodData.Length;;
            length++;
            for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            MethodData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ParamList.Length;
            for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SystemMessage ---" + Environment.NewLine;
                output += MethodData.ToString() + Environment.NewLine;
            for (int j = 0; j < ParamList.Length; j++)
            {
                output += ParamList[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MapLayerRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("maplayerrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint Flags;
            public uint EstateID;
            public bool Godlike;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 41;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(EstateID % 256);
                bytes[i++] = (byte)((EstateID >> 8) % 256);
                bytes[i++] = (byte)((EstateID >> 16) % 256);
                bytes[i++] = (byte)((EstateID >> 24) % 256);
                bytes[i++] = (byte)((Godlike) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("EstateID: {0}", EstateID));
                output.Append(String.Format("Godlike: {0}", Godlike));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapLayerRequest; } }
        public AgentDataBlock AgentData;

        public MapLayerRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 405;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public MapLayerRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public MapLayerRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapLayerRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MapLayerReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("maplayerreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("maplayerreply_layerdata")]
        public class LayerDataBlock
        {
            public uint Left;
            public uint Right;
            public uint Top;
            public uint Bottom;
            public LLUUID ImageID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public LayerDataBlock() { }
            public LayerDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Left = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Right = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Top = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Bottom = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ImageID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Left % 256);
                bytes[i++] = (byte)((Left >> 8) % 256);
                bytes[i++] = (byte)((Left >> 16) % 256);
                bytes[i++] = (byte)((Left >> 24) % 256);
                bytes[i++] = (byte)(Right % 256);
                bytes[i++] = (byte)((Right >> 8) % 256);
                bytes[i++] = (byte)((Right >> 16) % 256);
                bytes[i++] = (byte)((Right >> 24) % 256);
                bytes[i++] = (byte)(Top % 256);
                bytes[i++] = (byte)((Top >> 8) % 256);
                bytes[i++] = (byte)((Top >> 16) % 256);
                bytes[i++] = (byte)((Top >> 24) % 256);
                bytes[i++] = (byte)(Bottom % 256);
                bytes[i++] = (byte)((Bottom >> 8) % 256);
                bytes[i++] = (byte)((Bottom >> 16) % 256);
                bytes[i++] = (byte)((Bottom >> 24) % 256);
                Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- LayerData --");
                output.AppendLine(String.Format("Left: {0}", Left));
                output.AppendLine(String.Format("Right: {0}", Right));
                output.AppendLine(String.Format("Top: {0}", Top));
                output.AppendLine(String.Format("Bottom: {0}", Bottom));
                output.Append(String.Format("ImageID: {0}", ImageID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapLayerReply; } }
        public AgentDataBlock AgentData;
        public LayerDataBlock[] LayerData;

        public MapLayerReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 406;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            LayerData = new LayerDataBlock[0];
        }

        public MapLayerReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            LayerData = new LayerDataBlock[count];
            for (int j = 0; j < count; j++)
            { LayerData[j] = new LayerDataBlock(bytes, ref i); }
        }

        public MapLayerReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            LayerData = new LayerDataBlock[count];
            for (int j = 0; j < count; j++)
            { LayerData[j] = new LayerDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < LayerData.Length; j++) { length += LayerData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)LayerData.Length;
            for (int j = 0; j < LayerData.Length; j++) { LayerData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapLayerReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < LayerData.Length; j++)
            {
                output += LayerData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MapBlockRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("mapblockrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint Flags;
            public uint EstateID;
            public bool Godlike;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 41;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(EstateID % 256);
                bytes[i++] = (byte)((EstateID >> 8) % 256);
                bytes[i++] = (byte)((EstateID >> 16) % 256);
                bytes[i++] = (byte)((EstateID >> 24) % 256);
                bytes[i++] = (byte)((Godlike) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("EstateID: {0}", EstateID));
                output.Append(String.Format("Godlike: {0}", Godlike));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mapblockrequest_positiondata")]
        public class PositionDataBlock
        {
            public ushort MinX;
            public ushort MaxX;
            public ushort MinY;
            public ushort MaxY;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 8;
                }
            }

            public PositionDataBlock() { }
            public PositionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    MinX = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    MaxX = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    MinY = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    MaxY = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(MinX % 256);
                bytes[i++] = (byte)((MinX >> 8) % 256);
                bytes[i++] = (byte)(MaxX % 256);
                bytes[i++] = (byte)((MaxX >> 8) % 256);
                bytes[i++] = (byte)(MinY % 256);
                bytes[i++] = (byte)((MinY >> 8) % 256);
                bytes[i++] = (byte)(MaxY % 256);
                bytes[i++] = (byte)((MaxY >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PositionData --");
                output.AppendLine(String.Format("MinX: {0}", MinX));
                output.AppendLine(String.Format("MaxX: {0}", MaxX));
                output.AppendLine(String.Format("MinY: {0}", MinY));
                output.Append(String.Format("MaxY: {0}", MaxY));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapBlockRequest; } }
        public AgentDataBlock AgentData;
        public PositionDataBlock PositionData;

        public MapBlockRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 407;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            PositionData = new PositionDataBlock();
        }

        public MapBlockRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            PositionData = new PositionDataBlock(bytes, ref i);
        }

        public MapBlockRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            PositionData = new PositionDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += PositionData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            PositionData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapBlockRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += PositionData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MapNameRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("mapnamerequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint Flags;
            public uint EstateID;
            public bool Godlike;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 41;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(EstateID % 256);
                bytes[i++] = (byte)((EstateID >> 8) % 256);
                bytes[i++] = (byte)((EstateID >> 16) % 256);
                bytes[i++] = (byte)((EstateID >> 24) % 256);
                bytes[i++] = (byte)((Godlike) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("EstateID: {0}", EstateID));
                output.Append(String.Format("Godlike: {0}", Godlike));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mapnamerequest_namedata")]
        public class NameDataBlock
        {
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public NameDataBlock() { }
            public NameDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- NameData --");
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapNameRequest; } }
        public AgentDataBlock AgentData;
        public NameDataBlock NameData;

        public MapNameRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 408;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            NameData = new NameDataBlock();
        }

        public MapNameRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            NameData = new NameDataBlock(bytes, ref i);
        }

        public MapNameRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            NameData = new NameDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += NameData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            NameData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapNameRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += NameData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MapBlockReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("mapblockreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mapblockreply_data")]
        public class DataBlock
        {
            public ushort X;
            public ushort Y;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            public byte Access;
            public uint RegionFlags;
            public byte WaterHeight;
            public byte Agents;
            public LLUUID MapImageID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 27;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    X = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    Y = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    Access = (byte)bytes[i++];
                    RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    WaterHeight = (byte)bytes[i++];
                    Agents = (byte)bytes[i++];
                    MapImageID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(X % 256);
                bytes[i++] = (byte)((X >> 8) % 256);
                bytes[i++] = (byte)(Y % 256);
                bytes[i++] = (byte)((Y >> 8) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                bytes[i++] = Access;
                bytes[i++] = (byte)(RegionFlags % 256);
                bytes[i++] = (byte)((RegionFlags >> 8) % 256);
                bytes[i++] = (byte)((RegionFlags >> 16) % 256);
                bytes[i++] = (byte)((RegionFlags >> 24) % 256);
                bytes[i++] = WaterHeight;
                bytes[i++] = Agents;
                Buffer.BlockCopy(MapImageID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("X: {0}", X));
                output.AppendLine(String.Format("Y: {0}", Y));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Access: {0}", Access));
                output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
                output.AppendLine(String.Format("WaterHeight: {0}", WaterHeight));
                output.AppendLine(String.Format("Agents: {0}", Agents));
                output.Append(String.Format("MapImageID: {0}", MapImageID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapBlockReply; } }
        public AgentDataBlock AgentData;
        public DataBlock[] Data;

        public MapBlockReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 409;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock[0];
        }

        public MapBlockReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public MapBlockReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapBlockReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class MapItemRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("mapitemrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public uint Flags;
            public uint EstateID;
            public bool Godlike;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 41;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(EstateID % 256);
                bytes[i++] = (byte)((EstateID >> 8) % 256);
                bytes[i++] = (byte)((EstateID >> 16) % 256);
                bytes[i++] = (byte)((EstateID >> 24) % 256);
                bytes[i++] = (byte)((Godlike) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("EstateID: {0}", EstateID));
                output.Append(String.Format("Godlike: {0}", Godlike));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mapitemrequest_requestdata")]
        public class RequestDataBlock
        {
            public uint ItemType;
            public ulong RegionHandle;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public RequestDataBlock() { }
            public RequestDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ItemType % 256);
                bytes[i++] = (byte)((ItemType >> 8) % 256);
                bytes[i++] = (byte)((ItemType >> 16) % 256);
                bytes[i++] = (byte)((ItemType >> 24) % 256);
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestData --");
                output.AppendLine(String.Format("ItemType: {0}", ItemType));
                output.Append(String.Format("RegionHandle: {0}", RegionHandle));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapItemRequest; } }
        public AgentDataBlock AgentData;
        public RequestDataBlock RequestData;

        public MapItemRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 410;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RequestData = new RequestDataBlock();
        }

        public MapItemRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestData = new RequestDataBlock(bytes, ref i);
        }

        public MapItemRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestData = new RequestDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RequestData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RequestData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapItemRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RequestData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MapItemReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("mapitemreply_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public uint Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mapitemreply_requestdata")]
        public class RequestDataBlock
        {
            public uint ItemType;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public RequestDataBlock() { }
            public RequestDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ItemType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ItemType % 256);
                bytes[i++] = (byte)((ItemType >> 8) % 256);
                bytes[i++] = (byte)((ItemType >> 16) % 256);
                bytes[i++] = (byte)((ItemType >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestData --");
                output.Append(String.Format("ItemType: {0}", ItemType));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("mapitemreply_data")]
        public class DataBlock
        {
            public uint X;
            public uint Y;
            public LLUUID ID;
            public int Extra;
            public int Extra2;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 32;
                    if (Name != null) { length += 1 + Name.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    X = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Y = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ID = new LLUUID(bytes, i); i += 16;
                    Extra = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Extra2 = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(X % 256);
                bytes[i++] = (byte)((X >> 8) % 256);
                bytes[i++] = (byte)((X >> 16) % 256);
                bytes[i++] = (byte)((X >> 24) % 256);
                bytes[i++] = (byte)(Y % 256);
                bytes[i++] = (byte)((Y >> 8) % 256);
                bytes[i++] = (byte)((Y >> 16) % 256);
                bytes[i++] = (byte)((Y >> 24) % 256);
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Extra % 256);
                bytes[i++] = (byte)((Extra >> 8) % 256);
                bytes[i++] = (byte)((Extra >> 16) % 256);
                bytes[i++] = (byte)((Extra >> 24) % 256);
                bytes[i++] = (byte)(Extra2 % 256);
                bytes[i++] = (byte)((Extra2 >> 8) % 256);
                bytes[i++] = (byte)((Extra2 >> 16) % 256);
                bytes[i++] = (byte)((Extra2 >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("X: {0}", X));
                output.AppendLine(String.Format("Y: {0}", Y));
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("Extra: {0}", Extra));
                output.AppendLine(String.Format("Extra2: {0}", Extra2));
                Helpers.FieldToString(output, Name, "Name");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MapItemReply; } }
        public AgentDataBlock AgentData;
        public RequestDataBlock RequestData;
        public DataBlock[] Data;

        public MapItemReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 411;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RequestData = new RequestDataBlock();
            Data = new DataBlock[0];
        }

        public MapItemReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestData = new RequestDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public MapItemReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestData = new RequestDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Data = new DataBlock[count];
            for (int j = 0; j < count; j++)
            { Data[j] = new DataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RequestData.Length;;
            length++;
            for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RequestData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Data.Length;
            for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MapItemReply ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RequestData.ToString() + Environment.NewLine;
            for (int j = 0; j < Data.Length; j++)
            {
                output += Data[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class SendPostcardPacket : Packet
    {
        /// <exclude/>
        [XmlType("sendpostcard_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID AssetID;
            public LLVector3d PosGlobal;
            private byte[] _to;
            public byte[] To
            {
                get { return _to; }
                set
                {
                    if (value == null) { _to = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _to = new byte[value.Length]; Buffer.BlockCopy(value, 0, _to, 0, value.Length); }
                }
            }
            private byte[] _from;
            public byte[] From
            {
                get { return _from; }
                set
                {
                    if (value == null) { _from = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _from = new byte[value.Length]; Buffer.BlockCopy(value, 0, _from, 0, value.Length); }
                }
            }
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _subject;
            public byte[] Subject
            {
                get { return _subject; }
                set
                {
                    if (value == null) { _subject = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _subject = new byte[value.Length]; Buffer.BlockCopy(value, 0, _subject, 0, value.Length); }
                }
            }
            private byte[] _msg;
            public byte[] Msg
            {
                get { return _msg; }
                set
                {
                    if (value == null) { _msg = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _msg = new byte[value.Length]; Buffer.BlockCopy(value, 0, _msg, 0, value.Length); }
                }
            }
            public bool AllowPublish;
            public bool MaturePublish;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 74;
                    if (To != null) { length += 1 + To.Length; }
                    if (From != null) { length += 1 + From.Length; }
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Subject != null) { length += 1 + Subject.Length; }
                    if (Msg != null) { length += 2 + Msg.Length; }
                    return length;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    AssetID = new LLUUID(bytes, i); i += 16;
                    PosGlobal = new LLVector3d(bytes, i); i += 24;
                    length = (ushort)bytes[i++];
                    _to = new byte[length];
                    Buffer.BlockCopy(bytes, i, _to, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _from = new byte[length];
                    Buffer.BlockCopy(bytes, i, _from, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _subject = new byte[length];
                    Buffer.BlockCopy(bytes, i, _subject, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _msg = new byte[length];
                    Buffer.BlockCopy(bytes, i, _msg, 0, length); i += length;
                    AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
                if(To == null) { Console.WriteLine("Warning: To is null, in " + this.GetType()); }
                bytes[i++] = (byte)To.Length;
                Buffer.BlockCopy(To, 0, bytes, i, To.Length); i += To.Length;
                if(From == null) { Console.WriteLine("Warning: From is null, in " + this.GetType()); }
                bytes[i++] = (byte)From.Length;
                Buffer.BlockCopy(From, 0, bytes, i, From.Length); i += From.Length;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Subject == null) { Console.WriteLine("Warning: Subject is null, in " + this.GetType()); }
                bytes[i++] = (byte)Subject.Length;
                Buffer.BlockCopy(Subject, 0, bytes, i, Subject.Length); i += Subject.Length;
                if(Msg == null) { Console.WriteLine("Warning: Msg is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Msg.Length % 256);
                bytes[i++] = (byte)((Msg.Length >> 8) % 256);
                Buffer.BlockCopy(Msg, 0, bytes, i, Msg.Length); i += Msg.Length;
                bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
                bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("AssetID: {0}", AssetID));
                output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
                Helpers.FieldToString(output, To, "To");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, From, "From");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Subject, "Subject");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Msg, "Msg");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
                output.Append(String.Format("MaturePublish: {0}", MaturePublish));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SendPostcard; } }
        public AgentDataBlock AgentData;

        public SendPostcardPacket()
        {
            Header = new LowHeader();
            Header.ID = 412;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public SendPostcardPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public SendPostcardPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SendPostcard ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelMediaCommandMessagePacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelmediacommandmessage_commandblock")]
        public class CommandBlockBlock
        {
            public uint Flags;
            public uint Command;
            public float Time;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public CommandBlockBlock() { }
            public CommandBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Command = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Time = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(Flags % 256);
                bytes[i++] = (byte)((Flags >> 8) % 256);
                bytes[i++] = (byte)((Flags >> 16) % 256);
                bytes[i++] = (byte)((Flags >> 24) % 256);
                bytes[i++] = (byte)(Command % 256);
                bytes[i++] = (byte)((Command >> 8) % 256);
                bytes[i++] = (byte)((Command >> 16) % 256);
                bytes[i++] = (byte)((Command >> 24) % 256);
                ba = BitConverter.GetBytes(Time);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- CommandBlock --");
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("Command: {0}", Command));
                output.Append(String.Format("Time: {0}", Time));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelMediaCommandMessage; } }
        public CommandBlockBlock CommandBlock;

        public ParcelMediaCommandMessagePacket()
        {
            Header = new LowHeader();
            Header.ID = 419;
            Header.Reliable = true;
            CommandBlock = new CommandBlockBlock();
        }

        public ParcelMediaCommandMessagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            CommandBlock = new CommandBlockBlock(bytes, ref i);
        }

        public ParcelMediaCommandMessagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            CommandBlock = new CommandBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += CommandBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            CommandBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelMediaCommandMessage ---" + Environment.NewLine;
                output += CommandBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelMediaUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelmediaupdate_datablock")]
        public class DataBlockBlock
        {
            private byte[] _mediaurl;
            public byte[] MediaURL
            {
                get { return _mediaurl; }
                set
                {
                    if (value == null) { _mediaurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
                }
            }
            public LLUUID MediaID;
            public byte MediaAutoScale;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 17;
                    if (MediaURL != null) { length += 1 + MediaURL.Length; }
                    return length;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _mediaurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
                    MediaID = new LLUUID(bytes, i); i += 16;
                    MediaAutoScale = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MediaURL.Length;
                Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
                Buffer.BlockCopy(MediaID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = MediaAutoScale;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                Helpers.FieldToString(output, MediaURL, "MediaURL");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("MediaID: {0}", MediaID));
                output.Append(String.Format("MediaAutoScale: {0}", MediaAutoScale));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelMediaUpdate; } }
        public DataBlockBlock DataBlock;

        public ParcelMediaUpdatePacket()
        {
            Header = new LowHeader();
            Header.ID = 420;
            Header.Reliable = true;
            DataBlock = new DataBlockBlock();
        }

        public ParcelMediaUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public ParcelMediaUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelMediaUpdate ---" + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LandStatRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("landstatrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("landstatrequest_requestdata")]
        public class RequestDataBlock
        {
            public uint ReportType;
            public uint RequestFlags;
            private byte[] _filter;
            public byte[] Filter
            {
                get { return _filter; }
                set
                {
                    if (value == null) { _filter = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _filter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filter, 0, value.Length); }
                }
            }
            public int ParcelLocalID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 12;
                    if (Filter != null) { length += 1 + Filter.Length; }
                    return length;
                }
            }

            public RequestDataBlock() { }
            public RequestDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ReportType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _filter = new byte[length];
                    Buffer.BlockCopy(bytes, i, _filter, 0, length); i += length;
                    ParcelLocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ReportType % 256);
                bytes[i++] = (byte)((ReportType >> 8) % 256);
                bytes[i++] = (byte)((ReportType >> 16) % 256);
                bytes[i++] = (byte)((ReportType >> 24) % 256);
                bytes[i++] = (byte)(RequestFlags % 256);
                bytes[i++] = (byte)((RequestFlags >> 8) % 256);
                bytes[i++] = (byte)((RequestFlags >> 16) % 256);
                bytes[i++] = (byte)((RequestFlags >> 24) % 256);
                if(Filter == null) { Console.WriteLine("Warning: Filter is null, in " + this.GetType()); }
                bytes[i++] = (byte)Filter.Length;
                Buffer.BlockCopy(Filter, 0, bytes, i, Filter.Length); i += Filter.Length;
                bytes[i++] = (byte)(ParcelLocalID % 256);
                bytes[i++] = (byte)((ParcelLocalID >> 8) % 256);
                bytes[i++] = (byte)((ParcelLocalID >> 16) % 256);
                bytes[i++] = (byte)((ParcelLocalID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestData --");
                output.AppendLine(String.Format("ReportType: {0}", ReportType));
                output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
                Helpers.FieldToString(output, Filter, "Filter");
                output.Append(Environment.NewLine);
                output.Append(String.Format("ParcelLocalID: {0}", ParcelLocalID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LandStatRequest; } }
        public AgentDataBlock AgentData;
        public RequestDataBlock RequestData;

        public LandStatRequestPacket()
        {
            Header = new LowHeader();
            Header.ID = 421;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RequestData = new RequestDataBlock();
        }

        public LandStatRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestData = new RequestDataBlock(bytes, ref i);
        }

        public LandStatRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RequestData = new RequestDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += RequestData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RequestData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LandStatRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RequestData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LandStatReplyPacket : Packet
    {
        /// <exclude/>
        [XmlType("landstatreply_requestdata")]
        public class RequestDataBlock
        {
            public uint ReportType;
            public uint RequestFlags;
            public uint TotalObjectCount;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public RequestDataBlock() { }
            public RequestDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ReportType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TotalObjectCount = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ReportType % 256);
                bytes[i++] = (byte)((ReportType >> 8) % 256);
                bytes[i++] = (byte)((ReportType >> 16) % 256);
                bytes[i++] = (byte)((ReportType >> 24) % 256);
                bytes[i++] = (byte)(RequestFlags % 256);
                bytes[i++] = (byte)((RequestFlags >> 8) % 256);
                bytes[i++] = (byte)((RequestFlags >> 16) % 256);
                bytes[i++] = (byte)((RequestFlags >> 24) % 256);
                bytes[i++] = (byte)(TotalObjectCount % 256);
                bytes[i++] = (byte)((TotalObjectCount >> 8) % 256);
                bytes[i++] = (byte)((TotalObjectCount >> 16) % 256);
                bytes[i++] = (byte)((TotalObjectCount >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestData --");
                output.AppendLine(String.Format("ReportType: {0}", ReportType));
                output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
                output.Append(String.Format("TotalObjectCount: {0}", TotalObjectCount));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("landstatreply_reportdata")]
        public class ReportDataBlock
        {
            public uint TaskLocalID;
            public LLUUID TaskID;
            public float LocationX;
            public float LocationY;
            public float LocationZ;
            public float Score;
            private byte[] _taskname;
            public byte[] TaskName
            {
                get { return _taskname; }
                set
                {
                    if (value == null) { _taskname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _taskname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _taskname, 0, value.Length); }
                }
            }
            private byte[] _ownername;
            public byte[] OwnerName
            {
                get { return _ownername; }
                set
                {
                    if (value == null) { _ownername = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _ownername = new byte[value.Length]; Buffer.BlockCopy(value, 0, _ownername, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 36;
                    if (TaskName != null) { length += 1 + TaskName.Length; }
                    if (OwnerName != null) { length += 1 + OwnerName.Length; }
                    return length;
                }
            }

            public ReportDataBlock() { }
            public ReportDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TaskLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TaskID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    LocationX = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    LocationY = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    LocationZ = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Score = BitConverter.ToSingle(bytes, i); i += 4;
                    length = (ushort)bytes[i++];
                    _taskname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _taskname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _ownername = new byte[length];
                    Buffer.BlockCopy(bytes, i, _ownername, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(TaskLocalID % 256);
                bytes[i++] = (byte)((TaskLocalID >> 8) % 256);
                bytes[i++] = (byte)((TaskLocalID >> 16) % 256);
                bytes[i++] = (byte)((TaskLocalID >> 24) % 256);
                Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(LocationX);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(LocationY);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(LocationZ);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(Score);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                if(TaskName == null) { Console.WriteLine("Warning: TaskName is null, in " + this.GetType()); }
                bytes[i++] = (byte)TaskName.Length;
                Buffer.BlockCopy(TaskName, 0, bytes, i, TaskName.Length); i += TaskName.Length;
                if(OwnerName == null) { Console.WriteLine("Warning: OwnerName is null, in " + this.GetType()); }
                bytes[i++] = (byte)OwnerName.Length;
                Buffer.BlockCopy(OwnerName, 0, bytes, i, OwnerName.Length); i += OwnerName.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ReportData --");
                output.AppendLine(String.Format("TaskLocalID: {0}", TaskLocalID));
                output.AppendLine(String.Format("TaskID: {0}", TaskID));
                output.AppendLine(String.Format("LocationX: {0}", LocationX));
                output.AppendLine(String.Format("LocationY: {0}", LocationY));
                output.AppendLine(String.Format("LocationZ: {0}", LocationZ));
                output.AppendLine(String.Format("Score: {0}", Score));
                Helpers.FieldToString(output, TaskName, "TaskName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, OwnerName, "OwnerName");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LandStatReply; } }
        public RequestDataBlock RequestData;
        public ReportDataBlock[] ReportData;

        public LandStatReplyPacket()
        {
            Header = new LowHeader();
            Header.ID = 422;
            Header.Reliable = true;
            RequestData = new RequestDataBlock();
            ReportData = new ReportDataBlock[0];
        }

        public LandStatReplyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            RequestData = new RequestDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ReportData = new ReportDataBlock[count];
            for (int j = 0; j < count; j++)
            { ReportData[j] = new ReportDataBlock(bytes, ref i); }
        }

        public LandStatReplyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RequestData = new RequestDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ReportData = new ReportDataBlock[count];
            for (int j = 0; j < count; j++)
            { ReportData[j] = new ReportDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += RequestData.Length;;
            length++;
            for (int j = 0; j < ReportData.Length; j++) { length += ReportData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RequestData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ReportData.Length;
            for (int j = 0; j < ReportData.Length; j++) { ReportData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LandStatReply ---" + Environment.NewLine;
                output += RequestData.ToString() + Environment.NewLine;
            for (int j = 0; j < ReportData.Length; j++)
            {
                output += ReportData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ErrorPacket : Packet
    {
        /// <exclude/>
        [XmlType("error_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.Append(String.Format("AgentID: {0}", AgentID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("error_data")]
        public class DataBlock
        {
            public int Code;
            private byte[] _token;
            public byte[] Token
            {
                get { return _token; }
                set
                {
                    if (value == null) { _token = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _token = new byte[value.Length]; Buffer.BlockCopy(value, 0, _token, 0, value.Length); }
                }
            }
            public LLUUID ID;
            private byte[] _system;
            public byte[] System
            {
                get { return _system; }
                set
                {
                    if (value == null) { _system = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _system = new byte[value.Length]; Buffer.BlockCopy(value, 0, _system, 0, value.Length); }
                }
            }
            private byte[] _message;
            public byte[] Message
            {
                get { return _message; }
                set
                {
                    if (value == null) { _message = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
                }
            }
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 20;
                    if (Token != null) { length += 1 + Token.Length; }
                    if (System != null) { length += 1 + System.Length; }
                    if (Message != null) { length += 2 + Message.Length; }
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public DataBlock() { }
            public DataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    Code = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _token = new byte[length];
                    Buffer.BlockCopy(bytes, i, _token, 0, length); i += length;
                    ID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _system = new byte[length];
                    Buffer.BlockCopy(bytes, i, _system, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _message = new byte[length];
                    Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(Code % 256);
                bytes[i++] = (byte)((Code >> 8) % 256);
                bytes[i++] = (byte)((Code >> 16) % 256);
                bytes[i++] = (byte)((Code >> 24) % 256);
                if(Token == null) { Console.WriteLine("Warning: Token is null, in " + this.GetType()); }
                bytes[i++] = (byte)Token.Length;
                Buffer.BlockCopy(Token, 0, bytes, i, Token.Length); i += Token.Length;
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(System == null) { Console.WriteLine("Warning: System is null, in " + this.GetType()); }
                bytes[i++] = (byte)System.Length;
                Buffer.BlockCopy(System, 0, bytes, i, System.Length); i += System.Length;
                if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Message.Length % 256);
                bytes[i++] = (byte)((Message.Length >> 8) % 256);
                Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Data --");
                output.AppendLine(String.Format("Code: {0}", Code));
                Helpers.FieldToString(output, Token, "Token");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ID: {0}", ID));
                Helpers.FieldToString(output, System, "System");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Message, "Message");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.Error; } }
        public AgentDataBlock AgentData;
        public DataBlock Data;

        public ErrorPacket()
        {
            Header = new LowHeader();
            Header.ID = 423;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Data = new DataBlock();
        }

        public ErrorPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public ErrorPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            Data = new DataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += AgentData.Length;            length += Data.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            Data.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- Error ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += Data.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PacketAckPacket : Packet
    {
        /// <exclude/>
        [XmlType("packetack_packets")]
        public class PacketsBlock
        {
            public uint ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public PacketsBlock() { }
            public PacketsBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Packets --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PacketAck; } }
        public PacketsBlock[] Packets;

        public PacketAckPacket()
        {
            Header = new LowHeader();
            Header.ID = 65531;
            Header.Reliable = true;
            Packets = new PacketsBlock[0];
        }

        public PacketAckPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            Packets = new PacketsBlock[count];
            for (int j = 0; j < count; j++)
            { Packets[j] = new PacketsBlock(bytes, ref i); }
        }

        public PacketAckPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            Packets = new PacketsBlock[count];
            for (int j = 0; j < count; j++)
            { Packets[j] = new PacketsBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            length++;
            for (int j = 0; j < Packets.Length; j++) { length += Packets[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Packets.Length;
            for (int j = 0; j < Packets.Length; j++) { Packets[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PacketAck ---" + Environment.NewLine;
            for (int j = 0; j < Packets.Length; j++)
            {
                output += Packets[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class OpenCircuitPacket : Packet
    {
        /// <exclude/>
        [XmlType("opencircuit_circuitinfo")]
        public class CircuitInfoBlock
        {
            public uint IP;
            public ushort Port;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 6;
                }
            }

            public CircuitInfoBlock() { }
            public CircuitInfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    IP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Port = (ushort)((bytes[i++] << 8) + bytes[i++]);
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(IP % 256);
                bytes[i++] = (byte)((IP >> 8) % 256);
                bytes[i++] = (byte)((IP >> 16) % 256);
                bytes[i++] = (byte)((IP >> 24) % 256);
                bytes[i++] = (byte)((Port >> 8) % 256);
                bytes[i++] = (byte)(Port % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- CircuitInfo --");
                output.AppendLine(String.Format("IP: {0}", IP));
                output.Append(String.Format("Port: {0}", Port));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.OpenCircuit; } }
        public CircuitInfoBlock CircuitInfo;

        public OpenCircuitPacket()
        {
            Header = new LowHeader();
            Header.ID = 65532;
            Header.Reliable = true;
            CircuitInfo = new CircuitInfoBlock();
        }

        public OpenCircuitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
            CircuitInfo = new CircuitInfoBlock(bytes, ref i);
        }

        public OpenCircuitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            CircuitInfo = new CircuitInfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 10;
            length += CircuitInfo.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            CircuitInfo.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- OpenCircuit ---" + Environment.NewLine;
                output += CircuitInfo.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CloseCircuitPacket : Packet
    {
        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CloseCircuit; } }

        public CloseCircuitPacket()
        {
            Header = new LowHeader();
            Header.ID = 65533;
            Header.Reliable = true;
        }

        public CloseCircuitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new LowHeader(bytes, ref i, ref packetEnd);
        }

        public CloseCircuitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
        }

        public override byte[] ToBytes()
        {
            int length = 10;
;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CloseCircuit ---" + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectAddPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectadd_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLUUID GroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.Append(String.Format("GroupID: {0}", GroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectadd_objectdata")]
        public class ObjectDataBlock
        {
            public byte PCode;
            public byte Material;
            public uint AddFlags;
            public byte PathCurve;
            public byte ProfileCurve;
            public ushort PathBegin;
            public ushort PathEnd;
            public byte PathScaleX;
            public byte PathScaleY;
            public byte PathShearX;
            public byte PathShearY;
            public sbyte PathTwist;
            public sbyte PathTwistBegin;
            public sbyte PathRadiusOffset;
            public sbyte PathTaperX;
            public sbyte PathTaperY;
            public byte PathRevolutions;
            public sbyte PathSkew;
            public ushort ProfileBegin;
            public ushort ProfileEnd;
            public ushort ProfileHollow;
            public byte BypassRaycast;
            public LLVector3 RayStart;
            public LLVector3 RayEnd;
            public LLUUID RayTargetID;
            public byte RayEndIsIntersection;
            public LLVector3 Scale;
            public LLQuaternion Rotation;
            public byte State;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 96;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PCode = (byte)bytes[i++];
                    Material = (byte)bytes[i++];
                    AddFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PathCurve = (byte)bytes[i++];
                    ProfileCurve = (byte)bytes[i++];
                    PathBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    PathEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    PathScaleX = (byte)bytes[i++];
                    PathScaleY = (byte)bytes[i++];
                    PathShearX = (byte)bytes[i++];
                    PathShearY = (byte)bytes[i++];
                    PathTwist = (sbyte)bytes[i++];
                    PathTwistBegin = (sbyte)bytes[i++];
                    PathRadiusOffset = (sbyte)bytes[i++];
                    PathTaperX = (sbyte)bytes[i++];
                    PathTaperY = (sbyte)bytes[i++];
                    PathRevolutions = (byte)bytes[i++];
                    PathSkew = (sbyte)bytes[i++];
                    ProfileBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ProfileEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ProfileHollow = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    BypassRaycast = (byte)bytes[i++];
                    RayStart = new LLVector3(bytes, i); i += 12;
                    RayEnd = new LLVector3(bytes, i); i += 12;
                    RayTargetID = new LLUUID(bytes, i); i += 16;
                    RayEndIsIntersection = (byte)bytes[i++];
                    Scale = new LLVector3(bytes, i); i += 12;
                    Rotation = new LLQuaternion(bytes, i, true); i += 12;
                    State = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = PCode;
                bytes[i++] = Material;
                bytes[i++] = (byte)(AddFlags % 256);
                bytes[i++] = (byte)((AddFlags >> 8) % 256);
                bytes[i++] = (byte)((AddFlags >> 16) % 256);
                bytes[i++] = (byte)((AddFlags >> 24) % 256);
                bytes[i++] = PathCurve;
                bytes[i++] = ProfileCurve;
                bytes[i++] = (byte)(PathBegin % 256);
                bytes[i++] = (byte)((PathBegin >> 8) % 256);
                bytes[i++] = (byte)(PathEnd % 256);
                bytes[i++] = (byte)((PathEnd >> 8) % 256);
                bytes[i++] = PathScaleX;
                bytes[i++] = PathScaleY;
                bytes[i++] = PathShearX;
                bytes[i++] = PathShearY;
                bytes[i++] = (byte)PathTwist;
                bytes[i++] = (byte)PathTwistBegin;
                bytes[i++] = (byte)PathRadiusOffset;
                bytes[i++] = (byte)PathTaperX;
                bytes[i++] = (byte)PathTaperY;
                bytes[i++] = PathRevolutions;
                bytes[i++] = (byte)PathSkew;
                bytes[i++] = (byte)(ProfileBegin % 256);
                bytes[i++] = (byte)((ProfileBegin >> 8) % 256);
                bytes[i++] = (byte)(ProfileEnd % 256);
                bytes[i++] = (byte)((ProfileEnd >> 8) % 256);
                bytes[i++] = (byte)(ProfileHollow % 256);
                bytes[i++] = (byte)((ProfileHollow >> 8) % 256);
                bytes[i++] = BypassRaycast;
                Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = RayEndIsIntersection;
                Buffer.BlockCopy(Scale.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = State;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("PCode: {0}", PCode));
                output.AppendLine(String.Format("Material: {0}", Material));
                output.AppendLine(String.Format("AddFlags: {0}", AddFlags));
                output.AppendLine(String.Format("PathCurve: {0}", PathCurve));
                output.AppendLine(String.Format("ProfileCurve: {0}", ProfileCurve));
                output.AppendLine(String.Format("PathBegin: {0}", PathBegin));
                output.AppendLine(String.Format("PathEnd: {0}", PathEnd));
                output.AppendLine(String.Format("PathScaleX: {0}", PathScaleX));
                output.AppendLine(String.Format("PathScaleY: {0}", PathScaleY));
                output.AppendLine(String.Format("PathShearX: {0}", PathShearX));
                output.AppendLine(String.Format("PathShearY: {0}", PathShearY));
                output.AppendLine(String.Format("PathTwist: {0}", PathTwist));
                output.AppendLine(String.Format("PathTwistBegin: {0}", PathTwistBegin));
                output.AppendLine(String.Format("PathRadiusOffset: {0}", PathRadiusOffset));
                output.AppendLine(String.Format("PathTaperX: {0}", PathTaperX));
                output.AppendLine(String.Format("PathTaperY: {0}", PathTaperY));
                output.AppendLine(String.Format("PathRevolutions: {0}", PathRevolutions));
                output.AppendLine(String.Format("PathSkew: {0}", PathSkew));
                output.AppendLine(String.Format("ProfileBegin: {0}", ProfileBegin));
                output.AppendLine(String.Format("ProfileEnd: {0}", ProfileEnd));
                output.AppendLine(String.Format("ProfileHollow: {0}", ProfileHollow));
                output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
                output.AppendLine(String.Format("RayStart: {0}", RayStart));
                output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
                output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
                output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
                output.AppendLine(String.Format("Scale: {0}", Scale));
                output.AppendLine(String.Format("Rotation: {0}", Rotation));
                output.Append(String.Format("State: {0}", State));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectAdd; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public ObjectAddPacket()
        {
            Header = new MediumHeader();
            Header.ID = 1;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public ObjectAddPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectAddPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectAdd ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class MultipleObjectUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("multipleobjectupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("multipleobjectupdate_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public byte Type;
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 5;
                    if (Data != null) { length += 1 + Data.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Type = (byte)bytes[i++];
                    length = (ushort)bytes[i++];
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                bytes[i++] = Type;
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)Data.Length;
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.AppendLine(String.Format("Type: {0}", Type));
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.MultipleObjectUpdate; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public MultipleObjectUpdatePacket()
        {
            Header = new MediumHeader();
            Header.ID = 2;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public MultipleObjectUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public MultipleObjectUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- MultipleObjectUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RequestMultipleObjectsPacket : Packet
    {
        /// <exclude/>
        [XmlType("requestmultipleobjects_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("requestmultipleobjects_objectdata")]
        public class ObjectDataBlock
        {
            public byte CacheMissType;
            public uint ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 5;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    CacheMissType = (byte)bytes[i++];
                    ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = CacheMissType;
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("CacheMissType: {0}", CacheMissType));
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestMultipleObjects; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public RequestMultipleObjectsPacket()
        {
            Header = new MediumHeader();
            Header.ID = 3;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public RequestMultipleObjectsPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public RequestMultipleObjectsPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestMultipleObjects ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectPositionPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectposition_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectposition_objectdata")]
        public class ObjectDataBlock
        {
            public uint ObjectLocalID;
            public LLVector3 Position;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Position = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ObjectLocalID % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 8) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 16) % 256);
                bytes[i++] = (byte)((ObjectLocalID >> 24) % 256);
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
                output.Append(String.Format("Position: {0}", Position));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectPosition; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock[] ObjectData;

        public ObjectPositionPacket()
        {
            Header = new MediumHeader();
            Header.ID = 4;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectPositionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectPositionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectPosition ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class RequestObjectPropertiesFamilyPacket : Packet
    {
        /// <exclude/>
        [XmlType("requestobjectpropertiesfamily_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("requestobjectpropertiesfamily_objectdata")]
        public class ObjectDataBlock
        {
            public uint RequestFlags;
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RequestFlags % 256);
                bytes[i++] = (byte)((RequestFlags >> 8) % 256);
                bytes[i++] = (byte)((RequestFlags >> 16) % 256);
                bytes[i++] = (byte)((RequestFlags >> 24) % 256);
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestObjectPropertiesFamily; } }
        public AgentDataBlock AgentData;
        public ObjectDataBlock ObjectData;

        public RequestObjectPropertiesFamilyPacket()
        {
            Header = new MediumHeader();
            Header.ID = 5;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ObjectData = new ObjectDataBlock();
        }

        public RequestObjectPropertiesFamilyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public RequestObjectPropertiesFamilyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestObjectPropertiesFamily ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CoarseLocationUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("coarselocationupdate_location")]
        public class LocationBlock
        {
            public byte X;
            public byte Y;
            public byte Z;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 3;
                }
            }

            public LocationBlock() { }
            public LocationBlock(byte[] bytes, ref int i)
            {
                try
                {
                    X = (byte)bytes[i++];
                    Y = (byte)bytes[i++];
                    Z = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = X;
                bytes[i++] = Y;
                bytes[i++] = Z;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Location --");
                output.AppendLine(String.Format("X: {0}", X));
                output.AppendLine(String.Format("Y: {0}", Y));
                output.Append(String.Format("Z: {0}", Z));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("coarselocationupdate_index")]
        public class IndexBlock
        {
            public short You;
            public short Prey;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public IndexBlock() { }
            public IndexBlock(byte[] bytes, ref int i)
            {
                try
                {
                    You = (short)(bytes[i++] + (bytes[i++] << 8));
                    Prey = (short)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(You % 256);
                bytes[i++] = (byte)((You >> 8) % 256);
                bytes[i++] = (byte)(Prey % 256);
                bytes[i++] = (byte)((Prey >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Index --");
                output.AppendLine(String.Format("You: {0}", You));
                output.Append(String.Format("Prey: {0}", Prey));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CoarseLocationUpdate; } }
        public LocationBlock[] Location;
        public IndexBlock Index;

        public CoarseLocationUpdatePacket()
        {
            Header = new MediumHeader();
            Header.ID = 6;
            Header.Reliable = true;
            Location = new LocationBlock[0];
            Index = new IndexBlock();
        }

        public CoarseLocationUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            Location = new LocationBlock[count];
            for (int j = 0; j < count; j++)
            { Location[j] = new LocationBlock(bytes, ref i); }
            Index = new IndexBlock(bytes, ref i);
        }

        public CoarseLocationUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            Location = new LocationBlock[count];
            for (int j = 0; j < count; j++)
            { Location[j] = new LocationBlock(bytes, ref i); }
            Index = new IndexBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += Index.Length;;
            length++;
            for (int j = 0; j < Location.Length; j++) { length += Location[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Location.Length;
            for (int j = 0; j < Location.Length; j++) { Location[j].ToBytes(bytes, ref i); }
            Index.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CoarseLocationUpdate ---" + Environment.NewLine;
            for (int j = 0; j < Location.Length; j++)
            {
                output += Location[j].ToString() + Environment.NewLine;
            }
                output += Index.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CrossedRegionPacket : Packet
    {
        /// <exclude/>
        [XmlType("crossedregion_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("crossedregion_regiondata")]
        public class RegionDataBlock
        {
            public uint SimIP;
            public ushort SimPort;
            public ulong RegionHandle;
            private byte[] _seedcapability;
            public byte[] SeedCapability
            {
                get { return _seedcapability; }
                set
                {
                    if (value == null) { _seedcapability = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _seedcapability = new byte[value.Length]; Buffer.BlockCopy(value, 0, _seedcapability, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 14;
                    if (SeedCapability != null) { length += 2 + SeedCapability.Length; }
                    return length;
                }
            }

            public RegionDataBlock() { }
            public RegionDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    SimIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SimPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _seedcapability = new byte[length];
                    Buffer.BlockCopy(bytes, i, _seedcapability, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(SimIP % 256);
                bytes[i++] = (byte)((SimIP >> 8) % 256);
                bytes[i++] = (byte)((SimIP >> 16) % 256);
                bytes[i++] = (byte)((SimIP >> 24) % 256);
                bytes[i++] = (byte)((SimPort >> 8) % 256);
                bytes[i++] = (byte)(SimPort % 256);
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                if(SeedCapability == null) { Console.WriteLine("Warning: SeedCapability is null, in " + this.GetType()); }
                bytes[i++] = (byte)(SeedCapability.Length % 256);
                bytes[i++] = (byte)((SeedCapability.Length >> 8) % 256);
                Buffer.BlockCopy(SeedCapability, 0, bytes, i, SeedCapability.Length); i += SeedCapability.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionData --");
                output.AppendLine(String.Format("SimIP: {0}", SimIP));
                output.AppendLine(String.Format("SimPort: {0}", SimPort));
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                Helpers.FieldToString(output, SeedCapability, "SeedCapability");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("crossedregion_info")]
        public class InfoBlock
        {
            public LLVector3 Position;
            public LLVector3 LookAt;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 24;
                }
            }

            public InfoBlock() { }
            public InfoBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Position = new LLVector3(bytes, i); i += 12;
                    LookAt = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Info --");
                output.AppendLine(String.Format("Position: {0}", Position));
                output.Append(String.Format("LookAt: {0}", LookAt));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CrossedRegion; } }
        public AgentDataBlock AgentData;
        public RegionDataBlock RegionData;
        public InfoBlock Info;

        public CrossedRegionPacket()
        {
            Header = new MediumHeader();
            Header.ID = 7;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RegionData = new RegionDataBlock();
            Info = new InfoBlock();
        }

        public CrossedRegionPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionData = new RegionDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public CrossedRegionPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            RegionData = new RegionDataBlock(bytes, ref i);
            Info = new InfoBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;            length += RegionData.Length;            length += Info.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            RegionData.ToBytes(bytes, ref i);
            Info.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CrossedRegion ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += RegionData.ToString() + Environment.NewLine;
                output += Info.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ConfirmEnableSimulatorPacket : Packet
    {
        /// <exclude/>
        [XmlType("confirmenablesimulator_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ConfirmEnableSimulator; } }
        public AgentDataBlock AgentData;

        public ConfirmEnableSimulatorPacket()
        {
            Header = new MediumHeader();
            Header.ID = 8;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ConfirmEnableSimulatorPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ConfirmEnableSimulatorPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ConfirmEnableSimulator ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectPropertiesPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectproperties_objectdata")]
        public class ObjectDataBlock
        {
            public LLUUID ObjectID;
            public LLUUID CreatorID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public ulong CreationDate;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public int OwnershipCost;
            public byte SaleType;
            public int SalePrice;
            public byte AggregatePerms;
            public byte AggregatePermTextures;
            public byte AggregatePermTexturesOwner;
            public uint Category;
            public short InventorySerial;
            public LLUUID ItemID;
            public LLUUID FolderID;
            public LLUUID FromTaskID;
            public LLUUID LastOwnerID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }
            private byte[] _touchname;
            public byte[] TouchName
            {
                get { return _touchname; }
                set
                {
                    if (value == null) { _touchname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _touchname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _touchname, 0, value.Length); }
                }
            }
            private byte[] _sitname;
            public byte[] SitName
            {
                get { return _sitname; }
                set
                {
                    if (value == null) { _sitname = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _sitname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _sitname, 0, value.Length); }
                }
            }
            private byte[] _textureid;
            public byte[] TextureID
            {
                get { return _textureid; }
                set
                {
                    if (value == null) { _textureid = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _textureid = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureid, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 174;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    if (TouchName != null) { length += 1 + TouchName.Length; }
                    if (SitName != null) { length += 1 + SitName.Length; }
                    if (TextureID != null) { length += 1 + TextureID.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    CreatorID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    CreationDate = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnershipCost = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AggregatePerms = (byte)bytes[i++];
                    AggregatePermTextures = (byte)bytes[i++];
                    AggregatePermTexturesOwner = (byte)bytes[i++];
                    Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    InventorySerial = (short)(bytes[i++] + (bytes[i++] << 8));
                    ItemID = new LLUUID(bytes, i); i += 16;
                    FolderID = new LLUUID(bytes, i); i += 16;
                    FromTaskID = new LLUUID(bytes, i); i += 16;
                    LastOwnerID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _touchname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _touchname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _sitname = new byte[length];
                    Buffer.BlockCopy(bytes, i, _sitname, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _textureid = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureid, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CreationDate % 256);
                bytes[i++] = (byte)((CreationDate >> 8) % 256);
                bytes[i++] = (byte)((CreationDate >> 16) % 256);
                bytes[i++] = (byte)((CreationDate >> 24) % 256);
                bytes[i++] = (byte)((CreationDate >> 32) % 256);
                bytes[i++] = (byte)((CreationDate >> 40) % 256);
                bytes[i++] = (byte)((CreationDate >> 48) % 256);
                bytes[i++] = (byte)((CreationDate >> 56) % 256);
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)(OwnershipCost % 256);
                bytes[i++] = (byte)((OwnershipCost >> 8) % 256);
                bytes[i++] = (byte)((OwnershipCost >> 16) % 256);
                bytes[i++] = (byte)((OwnershipCost >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                bytes[i++] = AggregatePerms;
                bytes[i++] = AggregatePermTextures;
                bytes[i++] = AggregatePermTexturesOwner;
                bytes[i++] = (byte)(Category % 256);
                bytes[i++] = (byte)((Category >> 8) % 256);
                bytes[i++] = (byte)((Category >> 16) % 256);
                bytes[i++] = (byte)((Category >> 24) % 256);
                bytes[i++] = (byte)(InventorySerial % 256);
                bytes[i++] = (byte)((InventorySerial >> 8) % 256);
                Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(FromTaskID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(LastOwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
                if(TouchName == null) { Console.WriteLine("Warning: TouchName is null, in " + this.GetType()); }
                bytes[i++] = (byte)TouchName.Length;
                Buffer.BlockCopy(TouchName, 0, bytes, i, TouchName.Length); i += TouchName.Length;
                if(SitName == null) { Console.WriteLine("Warning: SitName is null, in " + this.GetType()); }
                bytes[i++] = (byte)SitName.Length;
                Buffer.BlockCopy(SitName, 0, bytes, i, SitName.Length); i += SitName.Length;
                if(TextureID == null) { Console.WriteLine("Warning: TextureID is null, in " + this.GetType()); }
                bytes[i++] = (byte)TextureID.Length;
                Buffer.BlockCopy(TextureID, 0, bytes, i, TextureID.Length); i += TextureID.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("OwnershipCost: {0}", OwnershipCost));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                output.AppendLine(String.Format("AggregatePerms: {0}", AggregatePerms));
                output.AppendLine(String.Format("AggregatePermTextures: {0}", AggregatePermTextures));
                output.AppendLine(String.Format("AggregatePermTexturesOwner: {0}", AggregatePermTexturesOwner));
                output.AppendLine(String.Format("Category: {0}", Category));
                output.AppendLine(String.Format("InventorySerial: {0}", InventorySerial));
                output.AppendLine(String.Format("ItemID: {0}", ItemID));
                output.AppendLine(String.Format("FolderID: {0}", FolderID));
                output.AppendLine(String.Format("FromTaskID: {0}", FromTaskID));
                output.AppendLine(String.Format("LastOwnerID: {0}", LastOwnerID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TouchName, "TouchName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, SitName, "SitName");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TextureID, "TextureID");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectProperties; } }
        public ObjectDataBlock[] ObjectData;

        public ObjectPropertiesPacket()
        {
            Header = new MediumHeader();
            Header.ID = 9;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectPropertiesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectPropertiesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 8;
;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectProperties ---" + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectPropertiesFamilyPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectpropertiesfamily_objectdata")]
        public class ObjectDataBlock
        {
            public uint RequestFlags;
            public LLUUID ObjectID;
            public LLUUID OwnerID;
            public LLUUID GroupID;
            public uint BaseMask;
            public uint OwnerMask;
            public uint GroupMask;
            public uint EveryoneMask;
            public uint NextOwnerMask;
            public int OwnershipCost;
            public byte SaleType;
            public int SalePrice;
            public uint Category;
            public LLUUID LastOwnerID;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _description;
            public byte[] Description
            {
                get { return _description; }
                set
                {
                    if (value == null) { _description = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 101;
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Description != null) { length += 1 + Description.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    GroupID = new LLUUID(bytes, i); i += 16;
                    BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnershipCost = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SaleType = (byte)bytes[i++];
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LastOwnerID = new LLUUID(bytes, i); i += 16;
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _description = new byte[length];
                    Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RequestFlags % 256);
                bytes[i++] = (byte)((RequestFlags >> 8) % 256);
                bytes[i++] = (byte)((RequestFlags >> 16) % 256);
                bytes[i++] = (byte)((RequestFlags >> 24) % 256);
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(BaseMask % 256);
                bytes[i++] = (byte)((BaseMask >> 8) % 256);
                bytes[i++] = (byte)((BaseMask >> 16) % 256);
                bytes[i++] = (byte)((BaseMask >> 24) % 256);
                bytes[i++] = (byte)(OwnerMask % 256);
                bytes[i++] = (byte)((OwnerMask >> 8) % 256);
                bytes[i++] = (byte)((OwnerMask >> 16) % 256);
                bytes[i++] = (byte)((OwnerMask >> 24) % 256);
                bytes[i++] = (byte)(GroupMask % 256);
                bytes[i++] = (byte)((GroupMask >> 8) % 256);
                bytes[i++] = (byte)((GroupMask >> 16) % 256);
                bytes[i++] = (byte)((GroupMask >> 24) % 256);
                bytes[i++] = (byte)(EveryoneMask % 256);
                bytes[i++] = (byte)((EveryoneMask >> 8) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 16) % 256);
                bytes[i++] = (byte)((EveryoneMask >> 24) % 256);
                bytes[i++] = (byte)(NextOwnerMask % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 8) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 16) % 256);
                bytes[i++] = (byte)((NextOwnerMask >> 24) % 256);
                bytes[i++] = (byte)(OwnershipCost % 256);
                bytes[i++] = (byte)((OwnershipCost >> 8) % 256);
                bytes[i++] = (byte)((OwnershipCost >> 16) % 256);
                bytes[i++] = (byte)((OwnershipCost >> 24) % 256);
                bytes[i++] = SaleType;
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                bytes[i++] = (byte)(Category % 256);
                bytes[i++] = (byte)((Category >> 8) % 256);
                bytes[i++] = (byte)((Category >> 16) % 256);
                bytes[i++] = (byte)((Category >> 24) % 256);
                Buffer.BlockCopy(LastOwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
                bytes[i++] = (byte)Description.Length;
                Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
                output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
                output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
                output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
                output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
                output.AppendLine(String.Format("OwnershipCost: {0}", OwnershipCost));
                output.AppendLine(String.Format("SaleType: {0}", SaleType));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                output.AppendLine(String.Format("Category: {0}", Category));
                output.AppendLine(String.Format("LastOwnerID: {0}", LastOwnerID));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Description, "Description");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectPropertiesFamily; } }
        public ObjectDataBlock ObjectData;

        public ObjectPropertiesFamilyPacket()
        {
            Header = new MediumHeader();
            Header.ID = 10;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock();
        }

        public ObjectPropertiesFamilyPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public ObjectPropertiesFamilyPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ObjectData = new ObjectDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += ObjectData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ObjectData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectPropertiesFamily ---" + Environment.NewLine;
                output += ObjectData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelPropertiesRequestPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelpropertiesrequest_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("parcelpropertiesrequest_parceldata")]
        public class ParcelDataBlock
        {
            public int SequenceID;
            public float West;
            public float South;
            public float East;
            public float North;
            public bool SnapSelection;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 21;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    West = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    South = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    East = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    North = BitConverter.ToSingle(bytes, i); i += 4;
                    SnapSelection = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                ba = BitConverter.GetBytes(West);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(South);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(East);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(North);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)((SnapSelection) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                output.AppendLine(String.Format("West: {0}", West));
                output.AppendLine(String.Format("South: {0}", South));
                output.AppendLine(String.Format("East: {0}", East));
                output.AppendLine(String.Format("North: {0}", North));
                output.Append(String.Format("SnapSelection: {0}", SnapSelection));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelPropertiesRequest; } }
        public AgentDataBlock AgentData;
        public ParcelDataBlock ParcelData;

        public ParcelPropertiesRequestPacket()
        {
            Header = new MediumHeader();
            Header.ID = 11;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            ParcelData = new ParcelDataBlock();
        }

        public ParcelPropertiesRequestPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelPropertiesRequestPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelPropertiesRequest ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AttachedSoundPacket : Packet
    {
        /// <exclude/>
        [XmlType("attachedsound_datablock")]
        public class DataBlockBlock
        {
            public LLUUID SoundID;
            public LLUUID ObjectID;
            public LLUUID OwnerID;
            public float Gain;
            public byte Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 53;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SoundID = new LLUUID(bytes, i); i += 16;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Gain = BitConverter.ToSingle(bytes, i); i += 4;
                    Flags = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(SoundID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(Gain);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = Flags;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                output.AppendLine(String.Format("SoundID: {0}", SoundID));
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("Gain: {0}", Gain));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AttachedSound; } }
        public DataBlockBlock DataBlock;

        public AttachedSoundPacket()
        {
            Header = new MediumHeader();
            Header.ID = 13;
            Header.Reliable = true;
            DataBlock = new DataBlockBlock();
        }

        public AttachedSoundPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public AttachedSoundPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AttachedSound ---" + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AttachedSoundGainChangePacket : Packet
    {
        /// <exclude/>
        [XmlType("attachedsoundgainchange_datablock")]
        public class DataBlockBlock
        {
            public LLUUID ObjectID;
            public float Gain;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Gain = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(Gain);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.Append(String.Format("Gain: {0}", Gain));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AttachedSoundGainChange; } }
        public DataBlockBlock DataBlock;

        public AttachedSoundGainChangePacket()
        {
            Header = new MediumHeader();
            Header.ID = 14;
            Header.Reliable = true;
            DataBlock = new DataBlockBlock();
        }

        public AttachedSoundGainChangePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public AttachedSoundGainChangePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            DataBlock = new DataBlockBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += DataBlock.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            DataBlock.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AttachedSoundGainChange ---" + Environment.NewLine;
                output += DataBlock.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class PreloadSoundPacket : Packet
    {
        /// <exclude/>
        [XmlType("preloadsound_datablock")]
        public class DataBlockBlock
        {
            public LLUUID ObjectID;
            public LLUUID OwnerID;
            public LLUUID SoundID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 48;
                }
            }

            public DataBlockBlock() { }
            public DataBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    SoundID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SoundID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataBlock --");
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.Append(String.Format("SoundID: {0}", SoundID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.PreloadSound; } }
        public DataBlockBlock[] DataBlock;

        public PreloadSoundPacket()
        {
            Header = new MediumHeader();
            Header.ID = 15;
            Header.Reliable = true;
            DataBlock = new DataBlockBlock[0];
        }

        public PreloadSoundPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            DataBlock = new DataBlockBlock[count];
            for (int j = 0; j < count; j++)
            { DataBlock[j] = new DataBlockBlock(bytes, ref i); }
        }

        public PreloadSoundPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            DataBlock = new DataBlockBlock[count];
            for (int j = 0; j < count; j++)
            { DataBlock[j] = new DataBlockBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 8;
;
            length++;
            for (int j = 0; j < DataBlock.Length; j++) { length += DataBlock[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)DataBlock.Length;
            for (int j = 0; j < DataBlock.Length; j++) { DataBlock[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- PreloadSound ---" + Environment.NewLine;
            for (int j = 0; j < DataBlock.Length; j++)
            {
                output += DataBlock[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ViewerEffectPacket : Packet
    {
        /// <exclude/>
        [XmlType("viewereffect_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("viewereffect_effect")]
        public class EffectBlock
        {
            public LLUUID ID;
            public LLUUID AgentID;
            public byte Type;
            public float Duration;
            public byte[] Color;
            private byte[] _typedata;
            public byte[] TypeData
            {
                get { return _typedata; }
                set
                {
                    if (value == null) { _typedata = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _typedata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _typedata, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 41;
                    if (TypeData != null) { length += 1 + TypeData.Length; }
                    return length;
                }
            }

            public EffectBlock() { }
            public EffectBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    AgentID = new LLUUID(bytes, i); i += 16;
                    Type = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Duration = BitConverter.ToSingle(bytes, i); i += 4;
                    Color = new byte[4];
                    Buffer.BlockCopy(bytes, i, Color, 0, 4); i += 4;
                    length = (ushort)bytes[i++];
                    _typedata = new byte[length];
                    Buffer.BlockCopy(bytes, i, _typedata, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = Type;
                ba = BitConverter.GetBytes(Duration);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                                Buffer.BlockCopy(Color, 0, bytes, i, 4);i += 4;
                if(TypeData == null) { Console.WriteLine("Warning: TypeData is null, in " + this.GetType()); }
                bytes[i++] = (byte)TypeData.Length;
                Buffer.BlockCopy(TypeData, 0, bytes, i, TypeData.Length); i += TypeData.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Effect --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("Type: {0}", Type));
                output.AppendLine(String.Format("Duration: {0}", Duration));
                Helpers.FieldToString(output, Color, "Color");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TypeData, "TypeData");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ViewerEffect; } }
        public AgentDataBlock AgentData;
        public EffectBlock[] Effect;

        public ViewerEffectPacket()
        {
            Header = new MediumHeader();
            Header.ID = 17;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            Effect = new EffectBlock[0];
        }

        public ViewerEffectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new MediumHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Effect = new EffectBlock[count];
            for (int j = 0; j < count; j++)
            { Effect[j] = new EffectBlock(bytes, ref i); }
        }

        public ViewerEffectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            Effect = new EffectBlock[count];
            for (int j = 0; j < count; j++)
            { Effect[j] = new EffectBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 8;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < Effect.Length; j++) { length += Effect[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)Effect.Length;
            for (int j = 0; j < Effect.Length; j++) { Effect[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ViewerEffect ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < Effect.Length; j++)
            {
                output += Effect[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class StartPingCheckPacket : Packet
    {
        /// <exclude/>
        [XmlType("startpingcheck_pingid")]
        public class PingIDBlock
        {
            public byte PingID;
            public uint OldestUnacked;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 5;
                }
            }

            public PingIDBlock() { }
            public PingIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PingID = (byte)bytes[i++];
                    OldestUnacked = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = PingID;
                bytes[i++] = (byte)(OldestUnacked % 256);
                bytes[i++] = (byte)((OldestUnacked >> 8) % 256);
                bytes[i++] = (byte)((OldestUnacked >> 16) % 256);
                bytes[i++] = (byte)((OldestUnacked >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PingID --");
                output.AppendLine(String.Format("PingID: {0}", PingID));
                output.Append(String.Format("OldestUnacked: {0}", OldestUnacked));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.StartPingCheck; } }
        public PingIDBlock PingID;

        public StartPingCheckPacket()
        {
            Header = new HighHeader();
            Header.ID = 1;
            Header.Reliable = true;
            PingID = new PingIDBlock();
        }

        public StartPingCheckPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            PingID = new PingIDBlock(bytes, ref i);
        }

        public StartPingCheckPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            PingID = new PingIDBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += PingID.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            PingID.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- StartPingCheck ---" + Environment.NewLine;
                output += PingID.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CompletePingCheckPacket : Packet
    {
        /// <exclude/>
        [XmlType("completepingcheck_pingid")]
        public class PingIDBlock
        {
            public byte PingID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public PingIDBlock() { }
            public PingIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    PingID = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = PingID;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PingID --");
                output.Append(String.Format("PingID: {0}", PingID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CompletePingCheck; } }
        public PingIDBlock PingID;

        public CompletePingCheckPacket()
        {
            Header = new HighHeader();
            Header.ID = 2;
            Header.Reliable = true;
            PingID = new PingIDBlock();
        }

        public CompletePingCheckPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            PingID = new PingIDBlock(bytes, ref i);
        }

        public CompletePingCheckPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            PingID = new PingIDBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += PingID.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            PingID.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CompletePingCheck ---" + Environment.NewLine;
                output += PingID.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("agentupdate_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLQuaternion BodyRotation;
            public LLQuaternion HeadRotation;
            public byte State;
            public LLVector3 CameraCenter;
            public LLVector3 CameraAtAxis;
            public LLVector3 CameraLeftAxis;
            public LLVector3 CameraUpAxis;
            public float Far;
            public uint ControlFlags;
            public byte Flags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 114;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    BodyRotation = new LLQuaternion(bytes, i, true); i += 12;
                    HeadRotation = new LLQuaternion(bytes, i, true); i += 12;
                    State = (byte)bytes[i++];
                    CameraCenter = new LLVector3(bytes, i); i += 12;
                    CameraAtAxis = new LLVector3(bytes, i); i += 12;
                    CameraLeftAxis = new LLVector3(bytes, i); i += 12;
                    CameraUpAxis = new LLVector3(bytes, i); i += 12;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Far = BitConverter.ToSingle(bytes, i); i += 4;
                    ControlFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Flags = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(BodyRotation.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(HeadRotation.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = State;
                Buffer.BlockCopy(CameraCenter.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(CameraAtAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(CameraLeftAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(CameraUpAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                ba = BitConverter.GetBytes(Far);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(ControlFlags % 256);
                bytes[i++] = (byte)((ControlFlags >> 8) % 256);
                bytes[i++] = (byte)((ControlFlags >> 16) % 256);
                bytes[i++] = (byte)((ControlFlags >> 24) % 256);
                bytes[i++] = Flags;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("BodyRotation: {0}", BodyRotation));
                output.AppendLine(String.Format("HeadRotation: {0}", HeadRotation));
                output.AppendLine(String.Format("State: {0}", State));
                output.AppendLine(String.Format("CameraCenter: {0}", CameraCenter));
                output.AppendLine(String.Format("CameraAtAxis: {0}", CameraAtAxis));
                output.AppendLine(String.Format("CameraLeftAxis: {0}", CameraLeftAxis));
                output.AppendLine(String.Format("CameraUpAxis: {0}", CameraUpAxis));
                output.AppendLine(String.Format("Far: {0}", Far));
                output.AppendLine(String.Format("ControlFlags: {0}", ControlFlags));
                output.Append(String.Format("Flags: {0}", Flags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentUpdate; } }
        public AgentDataBlock AgentData;

        public AgentUpdatePacket()
        {
            Header = new HighHeader();
            Header.ID = 4;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentAnimationPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentanimation_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentanimation_animationlist")]
        public class AnimationListBlock
        {
            public LLUUID AnimID;
            public bool StartAnim;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 17;
                }
            }

            public AnimationListBlock() { }
            public AnimationListBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AnimID = new LLUUID(bytes, i); i += 16;
                    StartAnim = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AnimID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((StartAnim) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AnimationList --");
                output.AppendLine(String.Format("AnimID: {0}", AnimID));
                output.Append(String.Format("StartAnim: {0}", StartAnim));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentanimation_physicalavatareventlist")]
        public class PhysicalAvatarEventListBlock
        {
            private byte[] _typedata;
            public byte[] TypeData
            {
                get { return _typedata; }
                set
                {
                    if (value == null) { _typedata = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _typedata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _typedata, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (TypeData != null) { length += 1 + TypeData.Length; }
                    return length;
                }
            }

            public PhysicalAvatarEventListBlock() { }
            public PhysicalAvatarEventListBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _typedata = new byte[length];
                    Buffer.BlockCopy(bytes, i, _typedata, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(TypeData == null) { Console.WriteLine("Warning: TypeData is null, in " + this.GetType()); }
                bytes[i++] = (byte)TypeData.Length;
                Buffer.BlockCopy(TypeData, 0, bytes, i, TypeData.Length); i += TypeData.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PhysicalAvatarEventList --");
                Helpers.FieldToString(output, TypeData, "TypeData");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentAnimation; } }
        public AgentDataBlock AgentData;
        public AnimationListBlock[] AnimationList;
        public PhysicalAvatarEventListBlock[] PhysicalAvatarEventList;

        public AgentAnimationPacket()
        {
            Header = new HighHeader();
            Header.ID = 5;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            AnimationList = new AnimationListBlock[0];
            PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[0];
        }

        public AgentAnimationPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            AnimationList = new AnimationListBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationList[j] = new AnimationListBlock(bytes, ref i); }
            count = (int)bytes[i++];
            PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
            for (int j = 0; j < count; j++)
            { PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock(bytes, ref i); }
        }

        public AgentAnimationPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            AnimationList = new AnimationListBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationList[j] = new AnimationListBlock(bytes, ref i); }
            count = (int)bytes[i++];
            PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
            for (int j = 0; j < count; j++)
            { PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < AnimationList.Length; j++) { length += AnimationList[j].Length; }
            length++;
            for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { length += PhysicalAvatarEventList[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)AnimationList.Length;
            for (int j = 0; j < AnimationList.Length; j++) { AnimationList[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)PhysicalAvatarEventList.Length;
            for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { PhysicalAvatarEventList[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentAnimation ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < AnimationList.Length; j++)
            {
                output += AnimationList[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < PhysicalAvatarEventList.Length; j++)
            {
                output += PhysicalAvatarEventList[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AgentRequestSitPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentrequestsit_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("agentrequestsit_targetobject")]
        public class TargetObjectBlock
        {
            public LLUUID TargetID;
            public LLVector3 Offset;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 28;
                }
            }

            public TargetObjectBlock() { }
            public TargetObjectBlock(byte[] bytes, ref int i)
            {
                try
                {
                    TargetID = new LLUUID(bytes, i); i += 16;
                    Offset = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(Offset.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TargetObject --");
                output.AppendLine(String.Format("TargetID: {0}", TargetID));
                output.Append(String.Format("Offset: {0}", Offset));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentRequestSit; } }
        public AgentDataBlock AgentData;
        public TargetObjectBlock TargetObject;

        public AgentRequestSitPacket()
        {
            Header = new HighHeader();
            Header.ID = 6;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            TargetObject = new TargetObjectBlock();
        }

        public AgentRequestSitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            TargetObject = new TargetObjectBlock(bytes, ref i);
        }

        public AgentRequestSitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            TargetObject = new TargetObjectBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;            length += TargetObject.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            TargetObject.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentRequestSit ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
                output += TargetObject.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AgentSitPacket : Packet
    {
        /// <exclude/>
        [XmlType("agentsit_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AgentSit; } }
        public AgentDataBlock AgentData;

        public AgentSitPacket()
        {
            Header = new HighHeader();
            Header.ID = 7;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public AgentSitPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public AgentSitPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AgentSit ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class RequestImagePacket : Packet
    {
        /// <exclude/>
        [XmlType("requestimage_agentdata")]
        public class AgentDataBlock
        {
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("requestimage_requestimage")]
        public class RequestImageBlock
        {
            public LLUUID Image;
            public sbyte DiscardLevel;
            public float DownloadPriority;
            public uint Packet;
            public byte Type;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 26;
                }
            }

            public RequestImageBlock() { }
            public RequestImageBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Image = new LLUUID(bytes, i); i += 16;
                    DiscardLevel = (sbyte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    DownloadPriority = BitConverter.ToSingle(bytes, i); i += 4;
                    Packet = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Type = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(Image.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)DiscardLevel;
                ba = BitConverter.GetBytes(DownloadPriority);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(Packet % 256);
                bytes[i++] = (byte)((Packet >> 8) % 256);
                bytes[i++] = (byte)((Packet >> 16) % 256);
                bytes[i++] = (byte)((Packet >> 24) % 256);
                bytes[i++] = Type;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RequestImage --");
                output.AppendLine(String.Format("Image: {0}", Image));
                output.AppendLine(String.Format("DiscardLevel: {0}", DiscardLevel));
                output.AppendLine(String.Format("DownloadPriority: {0}", DownloadPriority));
                output.AppendLine(String.Format("Packet: {0}", Packet));
                output.Append(String.Format("Type: {0}", Type));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.RequestImage; } }
        public AgentDataBlock AgentData;
        public RequestImageBlock[] RequestImage;

        public RequestImagePacket()
        {
            Header = new HighHeader();
            Header.ID = 8;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            RequestImage = new RequestImageBlock[0];
        }

        public RequestImagePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RequestImage = new RequestImageBlock[count];
            for (int j = 0; j < count; j++)
            { RequestImage[j] = new RequestImageBlock(bytes, ref i); }
        }

        public RequestImagePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            RequestImage = new RequestImageBlock[count];
            for (int j = 0; j < count; j++)
            { RequestImage[j] = new RequestImageBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < RequestImage.Length; j++) { length += RequestImage[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)RequestImage.Length;
            for (int j = 0; j < RequestImage.Length; j++) { RequestImage[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- RequestImage ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < RequestImage.Length; j++)
            {
                output += RequestImage[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ImageDataPacket : Packet
    {
        /// <exclude/>
        [XmlType("imagedata_imageid")]
        public class ImageIDBlock
        {
            public LLUUID ID;
            public byte Codec;
            public uint Size;
            public ushort Packets;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 23;
                }
            }

            public ImageIDBlock() { }
            public ImageIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    Codec = (byte)bytes[i++];
                    Size = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Packets = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = Codec;
                bytes[i++] = (byte)(Size % 256);
                bytes[i++] = (byte)((Size >> 8) % 256);
                bytes[i++] = (byte)((Size >> 16) % 256);
                bytes[i++] = (byte)((Size >> 24) % 256);
                bytes[i++] = (byte)(Packets % 256);
                bytes[i++] = (byte)((Packets >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ImageID --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("Codec: {0}", Codec));
                output.AppendLine(String.Format("Size: {0}", Size));
                output.Append(String.Format("Packets: {0}", Packets));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("imagedata_imagedata")]
        public class ImageDataBlock
        {
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public ImageDataBlock() { }
            public ImageDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ImageData --");
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ImageData; } }
        public ImageIDBlock ImageID;
        public ImageDataBlock ImageData;

        public ImageDataPacket()
        {
            Header = new HighHeader();
            Header.ID = 9;
            Header.Reliable = true;
            ImageID = new ImageIDBlock();
            ImageData = new ImageDataBlock();
        }

        public ImageDataPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            ImageID = new ImageIDBlock(bytes, ref i);
            ImageData = new ImageDataBlock(bytes, ref i);
        }

        public ImageDataPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ImageID = new ImageIDBlock(bytes, ref i);
            ImageData = new ImageDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += ImageID.Length;            length += ImageData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ImageID.ToBytes(bytes, ref i);
            ImageData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ImageData ---" + Environment.NewLine;
                output += ImageID.ToString() + Environment.NewLine;
                output += ImageData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ImagePacketPacket : Packet
    {
        /// <exclude/>
        [XmlType("imagepacket_imageid")]
        public class ImageIDBlock
        {
            public LLUUID ID;
            public ushort Packet;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 18;
                }
            }

            public ImageIDBlock() { }
            public ImageIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                    Packet = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Packet % 256);
                bytes[i++] = (byte)((Packet >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ImageID --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.Append(String.Format("Packet: {0}", Packet));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("imagepacket_imagedata")]
        public class ImageDataBlock
        {
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public ImageDataBlock() { }
            public ImageDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ImageData --");
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ImagePacket; } }
        public ImageIDBlock ImageID;
        public ImageDataBlock ImageData;

        public ImagePacketPacket()
        {
            Header = new HighHeader();
            Header.ID = 10;
            Header.Reliable = true;
            ImageID = new ImageIDBlock();
            ImageData = new ImageDataBlock();
        }

        public ImagePacketPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            ImageID = new ImageIDBlock(bytes, ref i);
            ImageData = new ImageDataBlock(bytes, ref i);
        }

        public ImagePacketPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ImageID = new ImageIDBlock(bytes, ref i);
            ImageData = new ImageDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += ImageID.Length;            length += ImageData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ImageID.ToBytes(bytes, ref i);
            ImageData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ImagePacket ---" + Environment.NewLine;
                output += ImageID.ToString() + Environment.NewLine;
                output += ImageData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class LayerDataPacket : Packet
    {
        /// <exclude/>
        [XmlType("layerdata_layerid")]
        public class LayerIDBlock
        {
            public byte Type;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public LayerIDBlock() { }
            public LayerIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Type = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = Type;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- LayerID --");
                output.Append(String.Format("Type: {0}", Type));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("layerdata_layerdata")]
        public class LayerDataBlock
        {
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public LayerDataBlock() { }
            public LayerDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- LayerData --");
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.LayerData; } }
        public LayerIDBlock LayerID;
        public LayerDataBlock LayerData;

        public LayerDataPacket()
        {
            Header = new HighHeader();
            Header.ID = 11;
            Header.Reliable = true;
            LayerID = new LayerIDBlock();
            LayerData = new LayerDataBlock();
        }

        public LayerDataPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            LayerID = new LayerIDBlock(bytes, ref i);
            LayerData = new LayerDataBlock(bytes, ref i);
        }

        public LayerDataPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            LayerID = new LayerIDBlock(bytes, ref i);
            LayerData = new LayerDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += LayerID.Length;            length += LayerData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            LayerID.ToBytes(bytes, ref i);
            LayerData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- LayerData ---" + Environment.NewLine;
                output += LayerID.ToString() + Environment.NewLine;
                output += LayerData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ObjectUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("objectupdate_regiondata")]
        public class RegionDataBlock
        {
            public ulong RegionHandle;
            public ushort TimeDilation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 10;
                }
            }

            public RegionDataBlock() { }
            public RegionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(TimeDilation % 256);
                bytes[i++] = (byte)((TimeDilation >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.Append(String.Format("TimeDilation: {0}", TimeDilation));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectupdate_objectdata")]
        public class ObjectDataBlock
        {
            public uint ID;
            public byte State;
            public LLUUID FullID;
            public uint CRC;
            public byte PCode;
            public byte Material;
            public byte ClickAction;
            public LLVector3 Scale;
            private byte[] _objectdata;
            public byte[] ObjectData
            {
                get { return _objectdata; }
                set
                {
                    if (value == null) { _objectdata = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _objectdata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectdata, 0, value.Length); }
                }
            }
            public uint ParentID;
            public uint UpdateFlags;
            public byte PathCurve;
            public byte ProfileCurve;
            public ushort PathBegin;
            public ushort PathEnd;
            public byte PathScaleX;
            public byte PathScaleY;
            public byte PathShearX;
            public byte PathShearY;
            public sbyte PathTwist;
            public sbyte PathTwistBegin;
            public sbyte PathRadiusOffset;
            public sbyte PathTaperX;
            public sbyte PathTaperY;
            public byte PathRevolutions;
            public sbyte PathSkew;
            public ushort ProfileBegin;
            public ushort ProfileEnd;
            public ushort ProfileHollow;
            private byte[] _textureentry;
            public byte[] TextureEntry
            {
                get { return _textureentry; }
                set
                {
                    if (value == null) { _textureentry = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
                }
            }
            private byte[] _textureanim;
            public byte[] TextureAnim
            {
                get { return _textureanim; }
                set
                {
                    if (value == null) { _textureanim = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _textureanim = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureanim, 0, value.Length); }
                }
            }
            private byte[] _namevalue;
            public byte[] NameValue
            {
                get { return _namevalue; }
                set
                {
                    if (value == null) { _namevalue = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _namevalue = new byte[value.Length]; Buffer.BlockCopy(value, 0, _namevalue, 0, value.Length); }
                }
            }
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }
            private byte[] _text;
            public byte[] Text
            {
                get { return _text; }
                set
                {
                    if (value == null) { _text = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _text = new byte[value.Length]; Buffer.BlockCopy(value, 0, _text, 0, value.Length); }
                }
            }
            public byte[] TextColor;
            private byte[] _mediaurl;
            public byte[] MediaURL
            {
                get { return _mediaurl; }
                set
                {
                    if (value == null) { _mediaurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
                }
            }
            private byte[] _psblock;
            public byte[] PSBlock
            {
                get { return _psblock; }
                set
                {
                    if (value == null) { _psblock = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _psblock = new byte[value.Length]; Buffer.BlockCopy(value, 0, _psblock, 0, value.Length); }
                }
            }
            private byte[] _extraparams;
            public byte[] ExtraParams
            {
                get { return _extraparams; }
                set
                {
                    if (value == null) { _extraparams = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _extraparams = new byte[value.Length]; Buffer.BlockCopy(value, 0, _extraparams, 0, value.Length); }
                }
            }
            public LLUUID Sound;
            public LLUUID OwnerID;
            public float Gain;
            public byte Flags;
            public float Radius;
            public byte JointType;
            public LLVector3 JointPivot;
            public LLVector3 JointAxisOrAnchor;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 141;
                    if (ObjectData != null) { length += 1 + ObjectData.Length; }
                    if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
                    if (TextureAnim != null) { length += 1 + TextureAnim.Length; }
                    if (NameValue != null) { length += 2 + NameValue.Length; }
                    if (Data != null) { length += 2 + Data.Length; }
                    if (Text != null) { length += 1 + Text.Length; }
                    if (MediaURL != null) { length += 1 + MediaURL.Length; }
                    if (PSBlock != null) { length += 1 + PSBlock.Length; }
                    if (ExtraParams != null) { length += 1 + ExtraParams.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    State = (byte)bytes[i++];
                    FullID = new LLUUID(bytes, i); i += 16;
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PCode = (byte)bytes[i++];
                    Material = (byte)bytes[i++];
                    ClickAction = (byte)bytes[i++];
                    Scale = new LLVector3(bytes, i); i += 12;
                    length = (ushort)bytes[i++];
                    _objectdata = new byte[length];
                    Buffer.BlockCopy(bytes, i, _objectdata, 0, length); i += length;
                    ParentID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    UpdateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PathCurve = (byte)bytes[i++];
                    ProfileCurve = (byte)bytes[i++];
                    PathBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    PathEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    PathScaleX = (byte)bytes[i++];
                    PathScaleY = (byte)bytes[i++];
                    PathShearX = (byte)bytes[i++];
                    PathShearY = (byte)bytes[i++];
                    PathTwist = (sbyte)bytes[i++];
                    PathTwistBegin = (sbyte)bytes[i++];
                    PathRadiusOffset = (sbyte)bytes[i++];
                    PathTaperX = (sbyte)bytes[i++];
                    PathTaperY = (sbyte)bytes[i++];
                    PathRevolutions = (byte)bytes[i++];
                    PathSkew = (sbyte)bytes[i++];
                    ProfileBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ProfileEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    ProfileHollow = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _textureentry = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _textureanim = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureanim, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _namevalue = new byte[length];
                    Buffer.BlockCopy(bytes, i, _namevalue, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _text = new byte[length];
                    Buffer.BlockCopy(bytes, i, _text, 0, length); i += length;
                    TextColor = new byte[4];
                    Buffer.BlockCopy(bytes, i, TextColor, 0, 4); i += 4;
                    length = (ushort)bytes[i++];
                    _mediaurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _psblock = new byte[length];
                    Buffer.BlockCopy(bytes, i, _psblock, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _extraparams = new byte[length];
                    Buffer.BlockCopy(bytes, i, _extraparams, 0, length); i += length;
                    Sound = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Gain = BitConverter.ToSingle(bytes, i); i += 4;
                    Flags = (byte)bytes[i++];
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Radius = BitConverter.ToSingle(bytes, i); i += 4;
                    JointType = (byte)bytes[i++];
                    JointPivot = new LLVector3(bytes, i); i += 12;
                    JointAxisOrAnchor = new LLVector3(bytes, i); i += 12;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
                bytes[i++] = State;
                Buffer.BlockCopy(FullID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
                bytes[i++] = PCode;
                bytes[i++] = Material;
                bytes[i++] = ClickAction;
                Buffer.BlockCopy(Scale.GetBytes(), 0, bytes, i, 12); i += 12;
                if(ObjectData == null) { Console.WriteLine("Warning: ObjectData is null, in " + this.GetType()); }
                bytes[i++] = (byte)ObjectData.Length;
                Buffer.BlockCopy(ObjectData, 0, bytes, i, ObjectData.Length); i += ObjectData.Length;
                bytes[i++] = (byte)(ParentID % 256);
                bytes[i++] = (byte)((ParentID >> 8) % 256);
                bytes[i++] = (byte)((ParentID >> 16) % 256);
                bytes[i++] = (byte)((ParentID >> 24) % 256);
                bytes[i++] = (byte)(UpdateFlags % 256);
                bytes[i++] = (byte)((UpdateFlags >> 8) % 256);
                bytes[i++] = (byte)((UpdateFlags >> 16) % 256);
                bytes[i++] = (byte)((UpdateFlags >> 24) % 256);
                bytes[i++] = PathCurve;
                bytes[i++] = ProfileCurve;
                bytes[i++] = (byte)(PathBegin % 256);
                bytes[i++] = (byte)((PathBegin >> 8) % 256);
                bytes[i++] = (byte)(PathEnd % 256);
                bytes[i++] = (byte)((PathEnd >> 8) % 256);
                bytes[i++] = PathScaleX;
                bytes[i++] = PathScaleY;
                bytes[i++] = PathShearX;
                bytes[i++] = PathShearY;
                bytes[i++] = (byte)PathTwist;
                bytes[i++] = (byte)PathTwistBegin;
                bytes[i++] = (byte)PathRadiusOffset;
                bytes[i++] = (byte)PathTaperX;
                bytes[i++] = (byte)PathTaperY;
                bytes[i++] = PathRevolutions;
                bytes[i++] = (byte)PathSkew;
                bytes[i++] = (byte)(ProfileBegin % 256);
                bytes[i++] = (byte)((ProfileBegin >> 8) % 256);
                bytes[i++] = (byte)(ProfileEnd % 256);
                bytes[i++] = (byte)((ProfileEnd >> 8) % 256);
                bytes[i++] = (byte)(ProfileHollow % 256);
                bytes[i++] = (byte)((ProfileHollow >> 8) % 256);
                if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
                bytes[i++] = (byte)(TextureEntry.Length % 256);
                bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
                Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
                if(TextureAnim == null) { Console.WriteLine("Warning: TextureAnim is null, in " + this.GetType()); }
                bytes[i++] = (byte)TextureAnim.Length;
                Buffer.BlockCopy(TextureAnim, 0, bytes, i, TextureAnim.Length); i += TextureAnim.Length;
                if(NameValue == null) { Console.WriteLine("Warning: NameValue is null, in " + this.GetType()); }
                bytes[i++] = (byte)(NameValue.Length % 256);
                bytes[i++] = (byte)((NameValue.Length >> 8) % 256);
                Buffer.BlockCopy(NameValue, 0, bytes, i, NameValue.Length); i += NameValue.Length;
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
                if(Text == null) { Console.WriteLine("Warning: Text is null, in " + this.GetType()); }
                bytes[i++] = (byte)Text.Length;
                Buffer.BlockCopy(Text, 0, bytes, i, Text.Length); i += Text.Length;
                                Buffer.BlockCopy(TextColor, 0, bytes, i, 4);i += 4;
                if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MediaURL.Length;
                Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
                if(PSBlock == null) { Console.WriteLine("Warning: PSBlock is null, in " + this.GetType()); }
                bytes[i++] = (byte)PSBlock.Length;
                Buffer.BlockCopy(PSBlock, 0, bytes, i, PSBlock.Length); i += PSBlock.Length;
                if(ExtraParams == null) { Console.WriteLine("Warning: ExtraParams is null, in " + this.GetType()); }
                bytes[i++] = (byte)ExtraParams.Length;
                Buffer.BlockCopy(ExtraParams, 0, bytes, i, ExtraParams.Length); i += ExtraParams.Length;
                Buffer.BlockCopy(Sound.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                ba = BitConverter.GetBytes(Gain);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = Flags;
                ba = BitConverter.GetBytes(Radius);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = JointType;
                Buffer.BlockCopy(JointPivot.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(JointAxisOrAnchor.GetBytes(), 0, bytes, i, 12); i += 12;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("State: {0}", State));
                output.AppendLine(String.Format("FullID: {0}", FullID));
                output.AppendLine(String.Format("CRC: {0}", CRC));
                output.AppendLine(String.Format("PCode: {0}", PCode));
                output.AppendLine(String.Format("Material: {0}", Material));
                output.AppendLine(String.Format("ClickAction: {0}", ClickAction));
                output.AppendLine(String.Format("Scale: {0}", Scale));
                Helpers.FieldToString(output, ObjectData, "ObjectData");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("ParentID: {0}", ParentID));
                output.AppendLine(String.Format("UpdateFlags: {0}", UpdateFlags));
                output.AppendLine(String.Format("PathCurve: {0}", PathCurve));
                output.AppendLine(String.Format("ProfileCurve: {0}", ProfileCurve));
                output.AppendLine(String.Format("PathBegin: {0}", PathBegin));
                output.AppendLine(String.Format("PathEnd: {0}", PathEnd));
                output.AppendLine(String.Format("PathScaleX: {0}", PathScaleX));
                output.AppendLine(String.Format("PathScaleY: {0}", PathScaleY));
                output.AppendLine(String.Format("PathShearX: {0}", PathShearX));
                output.AppendLine(String.Format("PathShearY: {0}", PathShearY));
                output.AppendLine(String.Format("PathTwist: {0}", PathTwist));
                output.AppendLine(String.Format("PathTwistBegin: {0}", PathTwistBegin));
                output.AppendLine(String.Format("PathRadiusOffset: {0}", PathRadiusOffset));
                output.AppendLine(String.Format("PathTaperX: {0}", PathTaperX));
                output.AppendLine(String.Format("PathTaperY: {0}", PathTaperY));
                output.AppendLine(String.Format("PathRevolutions: {0}", PathRevolutions));
                output.AppendLine(String.Format("PathSkew: {0}", PathSkew));
                output.AppendLine(String.Format("ProfileBegin: {0}", ProfileBegin));
                output.AppendLine(String.Format("ProfileEnd: {0}", ProfileEnd));
                output.AppendLine(String.Format("ProfileHollow: {0}", ProfileHollow));
                Helpers.FieldToString(output, TextureEntry, "TextureEntry");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TextureAnim, "TextureAnim");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, NameValue, "NameValue");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Data, "Data");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Text, "Text");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TextColor, "TextColor");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, MediaURL, "MediaURL");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, PSBlock, "PSBlock");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, ExtraParams, "ExtraParams");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Sound: {0}", Sound));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("Gain: {0}", Gain));
                output.AppendLine(String.Format("Flags: {0}", Flags));
                output.AppendLine(String.Format("Radius: {0}", Radius));
                output.AppendLine(String.Format("JointType: {0}", JointType));
                output.AppendLine(String.Format("JointPivot: {0}", JointPivot));
                output.Append(String.Format("JointAxisOrAnchor: {0}", JointAxisOrAnchor));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectUpdate; } }
        public RegionDataBlock RegionData;
        public ObjectDataBlock[] ObjectData;

        public ObjectUpdatePacket()
        {
            Header = new HighHeader();
            Header.ID = 12;
            Header.Reliable = true;
            RegionData = new RegionDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += RegionData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RegionData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectUpdate ---" + Environment.NewLine;
                output += RegionData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectUpdateCompressedPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectupdatecompressed_regiondata")]
        public class RegionDataBlock
        {
            public ulong RegionHandle;
            public ushort TimeDilation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 10;
                }
            }

            public RegionDataBlock() { }
            public RegionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(TimeDilation % 256);
                bytes[i++] = (byte)((TimeDilation >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.Append(String.Format("TimeDilation: {0}", TimeDilation));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectupdatecompressed_objectdata")]
        public class ObjectDataBlock
        {
            public uint UpdateFlags;
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 4;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    UpdateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(UpdateFlags % 256);
                bytes[i++] = (byte)((UpdateFlags >> 8) % 256);
                bytes[i++] = (byte)((UpdateFlags >> 16) % 256);
                bytes[i++] = (byte)((UpdateFlags >> 24) % 256);
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("UpdateFlags: {0}", UpdateFlags));
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectUpdateCompressed; } }
        public RegionDataBlock RegionData;
        public ObjectDataBlock[] ObjectData;

        public ObjectUpdateCompressedPacket()
        {
            Header = new HighHeader();
            Header.ID = 13;
            Header.Reliable = true;
            RegionData = new RegionDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectUpdateCompressedPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectUpdateCompressedPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += RegionData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RegionData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectUpdateCompressed ---" + Environment.NewLine;
                output += RegionData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ObjectUpdateCachedPacket : Packet
    {
        /// <exclude/>
        [XmlType("objectupdatecached_regiondata")]
        public class RegionDataBlock
        {
            public ulong RegionHandle;
            public ushort TimeDilation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 10;
                }
            }

            public RegionDataBlock() { }
            public RegionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(TimeDilation % 256);
                bytes[i++] = (byte)((TimeDilation >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.Append(String.Format("TimeDilation: {0}", TimeDilation));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("objectupdatecached_objectdata")]
        public class ObjectDataBlock
        {
            public uint ID;
            public uint CRC;
            public uint UpdateFlags;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    UpdateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
                bytes[i++] = (byte)(CRC % 256);
                bytes[i++] = (byte)((CRC >> 8) % 256);
                bytes[i++] = (byte)((CRC >> 16) % 256);
                bytes[i++] = (byte)((CRC >> 24) % 256);
                bytes[i++] = (byte)(UpdateFlags % 256);
                bytes[i++] = (byte)((UpdateFlags >> 8) % 256);
                bytes[i++] = (byte)((UpdateFlags >> 16) % 256);
                bytes[i++] = (byte)((UpdateFlags >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.AppendLine(String.Format("CRC: {0}", CRC));
                output.Append(String.Format("UpdateFlags: {0}", UpdateFlags));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ObjectUpdateCached; } }
        public RegionDataBlock RegionData;
        public ObjectDataBlock[] ObjectData;

        public ObjectUpdateCachedPacket()
        {
            Header = new HighHeader();
            Header.ID = 14;
            Header.Reliable = true;
            RegionData = new RegionDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ObjectUpdateCachedPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ObjectUpdateCachedPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += RegionData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RegionData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ObjectUpdateCached ---" + Environment.NewLine;
                output += RegionData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ImprovedTerseObjectUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("improvedterseobjectupdate_regiondata")]
        public class RegionDataBlock
        {
            public ulong RegionHandle;
            public ushort TimeDilation;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 10;
                }
            }

            public RegionDataBlock() { }
            public RegionDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(TimeDilation % 256);
                bytes[i++] = (byte)((TimeDilation >> 8) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- RegionData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.Append(String.Format("TimeDilation: {0}", TimeDilation));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("improvedterseobjectupdate_objectdata")]
        public class ObjectDataBlock
        {
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }
            private byte[] _textureentry;
            public byte[] TextureEntry
            {
                get { return _textureentry; }
                set
                {
                    if (value == null) { _textureentry = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Data != null) { length += 1 + Data.Length; }
                    if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
                    return length;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _textureentry = new byte[length];
                    Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)Data.Length;
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
                if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
                bytes[i++] = (byte)(TextureEntry.Length % 256);
                bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
                Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                Helpers.FieldToString(output, Data, "Data");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, TextureEntry, "TextureEntry");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ImprovedTerseObjectUpdate; } }
        public RegionDataBlock RegionData;
        public ObjectDataBlock[] ObjectData;

        public ImprovedTerseObjectUpdatePacket()
        {
            Header = new HighHeader();
            Header.ID = 15;
            Header.Reliable = true;
            RegionData = new RegionDataBlock();
            ObjectData = new ObjectDataBlock[0];
        }

        public ImprovedTerseObjectUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public ImprovedTerseObjectUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            RegionData = new RegionDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += RegionData.Length;;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            RegionData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ImprovedTerseObjectUpdate ---" + Environment.NewLine;
                output += RegionData.ToString() + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class KillObjectPacket : Packet
    {
        /// <exclude/>
        [XmlType("killobject_objectdata")]
        public class ObjectDataBlock
        {
            public uint ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 4;
                }
            }

            public ObjectDataBlock() { }
            public ObjectDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ObjectData --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.KillObject; } }
        public ObjectDataBlock[] ObjectData;

        public KillObjectPacket()
        {
            Header = new HighHeader();
            Header.ID = 16;
            Header.Reliable = true;
            ObjectData = new ObjectDataBlock[0];
        }

        public KillObjectPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public KillObjectPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            int count = (int)bytes[i++];
            ObjectData = new ObjectDataBlock[count];
            for (int j = 0; j < count; j++)
            { ObjectData[j] = new ObjectDataBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
;
            length++;
            for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            bytes[i++] = (byte)ObjectData.Length;
            for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- KillObject ---" + Environment.NewLine;
            for (int j = 0; j < ObjectData.Length; j++)
            {
                output += ObjectData[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class TransferPacketPacket : Packet
    {
        /// <exclude/>
        [XmlType("transferpacket_transferdata")]
        public class TransferDataBlock
        {
            public LLUUID TransferID;
            public int ChannelType;
            public int Packet;
            public int Status;
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 28;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public TransferDataBlock() { }
            public TransferDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    TransferID = new LLUUID(bytes, i); i += 16;
                    ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Packet = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Status = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(ChannelType % 256);
                bytes[i++] = (byte)((ChannelType >> 8) % 256);
                bytes[i++] = (byte)((ChannelType >> 16) % 256);
                bytes[i++] = (byte)((ChannelType >> 24) % 256);
                bytes[i++] = (byte)(Packet % 256);
                bytes[i++] = (byte)((Packet >> 8) % 256);
                bytes[i++] = (byte)((Packet >> 16) % 256);
                bytes[i++] = (byte)((Packet >> 24) % 256);
                bytes[i++] = (byte)(Status % 256);
                bytes[i++] = (byte)((Status >> 8) % 256);
                bytes[i++] = (byte)((Status >> 16) % 256);
                bytes[i++] = (byte)((Status >> 24) % 256);
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- TransferData --");
                output.AppendLine(String.Format("TransferID: {0}", TransferID));
                output.AppendLine(String.Format("ChannelType: {0}", ChannelType));
                output.AppendLine(String.Format("Packet: {0}", Packet));
                output.AppendLine(String.Format("Status: {0}", Status));
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.TransferPacket; } }
        public TransferDataBlock TransferData;

        public TransferPacketPacket()
        {
            Header = new HighHeader();
            Header.ID = 17;
            Header.Reliable = true;
            TransferData = new TransferDataBlock();
        }

        public TransferPacketPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            TransferData = new TransferDataBlock(bytes, ref i);
        }

        public TransferPacketPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            TransferData = new TransferDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += TransferData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            TransferData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- TransferPacket ---" + Environment.NewLine;
                output += TransferData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SendXferPacketPacket : Packet
    {
        /// <exclude/>
        [XmlType("sendxferpacket_xferid")]
        public class XferIDBlock
        {
            public ulong ID;
            public uint Packet;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public XferIDBlock() { }
            public XferIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Packet = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
                bytes[i++] = (byte)((ID >> 32) % 256);
                bytes[i++] = (byte)((ID >> 40) % 256);
                bytes[i++] = (byte)((ID >> 48) % 256);
                bytes[i++] = (byte)((ID >> 56) % 256);
                bytes[i++] = (byte)(Packet % 256);
                bytes[i++] = (byte)((Packet >> 8) % 256);
                bytes[i++] = (byte)((Packet >> 16) % 256);
                bytes[i++] = (byte)((Packet >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- XferID --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.Append(String.Format("Packet: {0}", Packet));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("sendxferpacket_datapacket")]
        public class DataPacketBlock
        {
            private byte[] _data;
            public byte[] Data
            {
                get { return _data; }
                set
                {
                    if (value == null) { _data = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (Data != null) { length += 2 + Data.Length; }
                    return length;
                }
            }

            public DataPacketBlock() { }
            public DataPacketBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _data = new byte[length];
                    Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Data.Length % 256);
                bytes[i++] = (byte)((Data.Length >> 8) % 256);
                Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- DataPacket --");
                Helpers.FieldToString(output, Data, "Data");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SendXferPacket; } }
        public XferIDBlock XferID;
        public DataPacketBlock DataPacket;

        public SendXferPacketPacket()
        {
            Header = new HighHeader();
            Header.ID = 18;
            Header.Reliable = true;
            XferID = new XferIDBlock();
            DataPacket = new DataPacketBlock();
        }

        public SendXferPacketPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            XferID = new XferIDBlock(bytes, ref i);
            DataPacket = new DataPacketBlock(bytes, ref i);
        }

        public SendXferPacketPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            XferID = new XferIDBlock(bytes, ref i);
            DataPacket = new DataPacketBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += XferID.Length;            length += DataPacket.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            XferID.ToBytes(bytes, ref i);
            DataPacket.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SendXferPacket ---" + Environment.NewLine;
                output += XferID.ToString() + Environment.NewLine;
                output += DataPacket.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ConfirmXferPacketPacket : Packet
    {
        /// <exclude/>
        [XmlType("confirmxferpacket_xferid")]
        public class XferIDBlock
        {
            public ulong ID;
            public uint Packet;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 12;
                }
            }

            public XferIDBlock() { }
            public XferIDBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Packet = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(ID % 256);
                bytes[i++] = (byte)((ID >> 8) % 256);
                bytes[i++] = (byte)((ID >> 16) % 256);
                bytes[i++] = (byte)((ID >> 24) % 256);
                bytes[i++] = (byte)((ID >> 32) % 256);
                bytes[i++] = (byte)((ID >> 40) % 256);
                bytes[i++] = (byte)((ID >> 48) % 256);
                bytes[i++] = (byte)((ID >> 56) % 256);
                bytes[i++] = (byte)(Packet % 256);
                bytes[i++] = (byte)((Packet >> 8) % 256);
                bytes[i++] = (byte)((Packet >> 16) % 256);
                bytes[i++] = (byte)((Packet >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- XferID --");
                output.AppendLine(String.Format("ID: {0}", ID));
                output.Append(String.Format("Packet: {0}", Packet));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ConfirmXferPacket; } }
        public XferIDBlock XferID;

        public ConfirmXferPacketPacket()
        {
            Header = new HighHeader();
            Header.ID = 19;
            Header.Reliable = true;
            XferID = new XferIDBlock();
        }

        public ConfirmXferPacketPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            XferID = new XferIDBlock(bytes, ref i);
        }

        public ConfirmXferPacketPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            XferID = new XferIDBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += XferID.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            XferID.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ConfirmXferPacket ---" + Environment.NewLine;
                output += XferID.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class AvatarAnimationPacket : Packet
    {
        /// <exclude/>
        [XmlType("avataranimation_sender")]
        public class SenderBlock
        {
            public LLUUID ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public SenderBlock() { }
            public SenderBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- Sender --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avataranimation_animationlist")]
        public class AnimationListBlock
        {
            public LLUUID AnimID;
            public int AnimSequenceID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 20;
                }
            }

            public AnimationListBlock() { }
            public AnimationListBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AnimID = new LLUUID(bytes, i); i += 16;
                    AnimSequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(AnimID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(AnimSequenceID % 256);
                bytes[i++] = (byte)((AnimSequenceID >> 8) % 256);
                bytes[i++] = (byte)((AnimSequenceID >> 16) % 256);
                bytes[i++] = (byte)((AnimSequenceID >> 24) % 256);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AnimationList --");
                output.AppendLine(String.Format("AnimID: {0}", AnimID));
                output.Append(String.Format("AnimSequenceID: {0}", AnimSequenceID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avataranimation_animationsourcelist")]
        public class AnimationSourceListBlock
        {
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public AnimationSourceListBlock() { }
            public AnimationSourceListBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AnimationSourceList --");
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avataranimation_physicalavatareventlist")]
        public class PhysicalAvatarEventListBlock
        {
            private byte[] _typedata;
            public byte[] TypeData
            {
                get { return _typedata; }
                set
                {
                    if (value == null) { _typedata = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _typedata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _typedata, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (TypeData != null) { length += 1 + TypeData.Length; }
                    return length;
                }
            }

            public PhysicalAvatarEventListBlock() { }
            public PhysicalAvatarEventListBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)bytes[i++];
                    _typedata = new byte[length];
                    Buffer.BlockCopy(bytes, i, _typedata, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(TypeData == null) { Console.WriteLine("Warning: TypeData is null, in " + this.GetType()); }
                bytes[i++] = (byte)TypeData.Length;
                Buffer.BlockCopy(TypeData, 0, bytes, i, TypeData.Length); i += TypeData.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- PhysicalAvatarEventList --");
                Helpers.FieldToString(output, TypeData, "TypeData");
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarAnimation; } }
        public SenderBlock Sender;
        public AnimationListBlock[] AnimationList;
        public AnimationSourceListBlock[] AnimationSourceList;
        public PhysicalAvatarEventListBlock[] PhysicalAvatarEventList;

        public AvatarAnimationPacket()
        {
            Header = new HighHeader();
            Header.ID = 20;
            Header.Reliable = true;
            Sender = new SenderBlock();
            AnimationList = new AnimationListBlock[0];
            AnimationSourceList = new AnimationSourceListBlock[0];
            PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[0];
        }

        public AvatarAnimationPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            Sender = new SenderBlock(bytes, ref i);
            int count = (int)bytes[i++];
            AnimationList = new AnimationListBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationList[j] = new AnimationListBlock(bytes, ref i); }
            count = (int)bytes[i++];
            AnimationSourceList = new AnimationSourceListBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationSourceList[j] = new AnimationSourceListBlock(bytes, ref i); }
            count = (int)bytes[i++];
            PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
            for (int j = 0; j < count; j++)
            { PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock(bytes, ref i); }
        }

        public AvatarAnimationPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            Sender = new SenderBlock(bytes, ref i);
            int count = (int)bytes[i++];
            AnimationList = new AnimationListBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationList[j] = new AnimationListBlock(bytes, ref i); }
            count = (int)bytes[i++];
            AnimationSourceList = new AnimationSourceListBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationSourceList[j] = new AnimationSourceListBlock(bytes, ref i); }
            count = (int)bytes[i++];
            PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
            for (int j = 0; j < count; j++)
            { PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += Sender.Length;;
            length++;
            for (int j = 0; j < AnimationList.Length; j++) { length += AnimationList[j].Length; }
            length++;
            for (int j = 0; j < AnimationSourceList.Length; j++) { length += AnimationSourceList[j].Length; }
            length++;
            for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { length += PhysicalAvatarEventList[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            Sender.ToBytes(bytes, ref i);
            bytes[i++] = (byte)AnimationList.Length;
            for (int j = 0; j < AnimationList.Length; j++) { AnimationList[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)AnimationSourceList.Length;
            for (int j = 0; j < AnimationSourceList.Length; j++) { AnimationSourceList[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)PhysicalAvatarEventList.Length;
            for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { PhysicalAvatarEventList[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarAnimation ---" + Environment.NewLine;
                output += Sender.ToString() + Environment.NewLine;
            for (int j = 0; j < AnimationList.Length; j++)
            {
                output += AnimationList[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < AnimationSourceList.Length; j++)
            {
                output += AnimationSourceList[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < PhysicalAvatarEventList.Length; j++)
            {
                output += PhysicalAvatarEventList[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class AvatarSitResponsePacket : Packet
    {
        /// <exclude/>
        [XmlType("avatarsitresponse_sitobject")]
        public class SitObjectBlock
        {
            public LLUUID ID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public SitObjectBlock() { }
            public SitObjectBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SitObject --");
                output.Append(String.Format("ID: {0}", ID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("avatarsitresponse_sittransform")]
        public class SitTransformBlock
        {
            public bool AutoPilot;
            public LLVector3 SitPosition;
            public LLQuaternion SitRotation;
            public LLVector3 CameraEyeOffset;
            public LLVector3 CameraAtOffset;
            public bool ForceMouselook;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 50;
                }
            }

            public SitTransformBlock() { }
            public SitTransformBlock(byte[] bytes, ref int i)
            {
                try
                {
                    AutoPilot = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    SitPosition = new LLVector3(bytes, i); i += 12;
                    SitRotation = new LLQuaternion(bytes, i, true); i += 12;
                    CameraEyeOffset = new LLVector3(bytes, i); i += 12;
                    CameraAtOffset = new LLVector3(bytes, i); i += 12;
                    ForceMouselook = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)((AutoPilot) ? 1 : 0);
                Buffer.BlockCopy(SitPosition.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(SitRotation.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(CameraEyeOffset.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(CameraAtOffset.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)((ForceMouselook) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SitTransform --");
                output.AppendLine(String.Format("AutoPilot: {0}", AutoPilot));
                output.AppendLine(String.Format("SitPosition: {0}", SitPosition));
                output.AppendLine(String.Format("SitRotation: {0}", SitRotation));
                output.AppendLine(String.Format("CameraEyeOffset: {0}", CameraEyeOffset));
                output.AppendLine(String.Format("CameraAtOffset: {0}", CameraAtOffset));
                output.Append(String.Format("ForceMouselook: {0}", ForceMouselook));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.AvatarSitResponse; } }
        public SitObjectBlock SitObject;
        public SitTransformBlock SitTransform;

        public AvatarSitResponsePacket()
        {
            Header = new HighHeader();
            Header.ID = 21;
            Header.Reliable = true;
            SitObject = new SitObjectBlock();
            SitTransform = new SitTransformBlock();
        }

        public AvatarSitResponsePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            SitObject = new SitObjectBlock(bytes, ref i);
            SitTransform = new SitTransformBlock(bytes, ref i);
        }

        public AvatarSitResponsePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            SitObject = new SitObjectBlock(bytes, ref i);
            SitTransform = new SitTransformBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += SitObject.Length;            length += SitTransform.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            SitObject.ToBytes(bytes, ref i);
            SitTransform.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- AvatarSitResponse ---" + Environment.NewLine;
                output += SitObject.ToString() + Environment.NewLine;
                output += SitTransform.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class CameraConstraintPacket : Packet
    {
        /// <exclude/>
        [XmlType("cameraconstraint_cameracollideplane")]
        public class CameraCollidePlaneBlock
        {
            public LLVector4 Plane;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public CameraCollidePlaneBlock() { }
            public CameraCollidePlaneBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Plane = new LLVector4(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(Plane.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- CameraCollidePlane --");
                output.Append(String.Format("Plane: {0}", Plane));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.CameraConstraint; } }
        public CameraCollidePlaneBlock CameraCollidePlane;

        public CameraConstraintPacket()
        {
            Header = new HighHeader();
            Header.ID = 22;
            Header.Reliable = true;
            CameraCollidePlane = new CameraCollidePlaneBlock();
        }

        public CameraConstraintPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            CameraCollidePlane = new CameraCollidePlaneBlock(bytes, ref i);
        }

        public CameraConstraintPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            CameraCollidePlane = new CameraCollidePlaneBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += CameraCollidePlane.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            CameraCollidePlane.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- CameraConstraint ---" + Environment.NewLine;
                output += CameraCollidePlane.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ParcelPropertiesPacket : Packet
    {
        /// <exclude/>
        [XmlType("parcelproperties_parceldata")]
        public class ParcelDataBlock
        {
            public int RequestResult;
            public int SequenceID;
            public bool SnapSelection;
            public int SelfCount;
            public int OtherCount;
            public int PublicCount;
            public int LocalID;
            public LLUUID OwnerID;
            public bool IsGroupOwned;
            public uint AuctionID;
            public int ClaimDate;
            public int ClaimPrice;
            public int RentPrice;
            public LLVector3 AABBMin;
            public LLVector3 AABBMax;
            private byte[] _bitmap;
            public byte[] Bitmap
            {
                get { return _bitmap; }
                set
                {
                    if (value == null) { _bitmap = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _bitmap = new byte[value.Length]; Buffer.BlockCopy(value, 0, _bitmap, 0, value.Length); }
                }
            }
            public int Area;
            public byte Status;
            public int SimWideMaxPrims;
            public int SimWideTotalPrims;
            public int MaxPrims;
            public int TotalPrims;
            public int OwnerPrims;
            public int GroupPrims;
            public int OtherPrims;
            public int SelectedPrims;
            public float ParcelPrimBonus;
            public int OtherCleanTime;
            public uint ParcelFlags;
            public int SalePrice;
            private byte[] _name;
            public byte[] Name
            {
                get { return _name; }
                set
                {
                    if (value == null) { _name = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
                }
            }
            private byte[] _desc;
            public byte[] Desc
            {
                get { return _desc; }
                set
                {
                    if (value == null) { _desc = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
                }
            }
            private byte[] _musicurl;
            public byte[] MusicURL
            {
                get { return _musicurl; }
                set
                {
                    if (value == null) { _musicurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _musicurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _musicurl, 0, value.Length); }
                }
            }
            private byte[] _mediaurl;
            public byte[] MediaURL
            {
                get { return _mediaurl; }
                set
                {
                    if (value == null) { _mediaurl = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
                }
            }
            public LLUUID MediaID;
            public byte MediaAutoScale;
            public LLUUID GroupID;
            public int PassPrice;
            public float PassHours;
            public byte Category;
            public LLUUID AuthBuyerID;
            public LLUUID SnapshotID;
            public LLVector3 UserLocation;
            public LLVector3 UserLookAt;
            public byte LandingType;
            public bool RegionPushOverride;
            public bool RegionDenyAnonymous;
            public bool RegionDenyIdentified;
            public bool RegionDenyTransacted;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 238;
                    if (Bitmap != null) { length += 2 + Bitmap.Length; }
                    if (Name != null) { length += 1 + Name.Length; }
                    if (Desc != null) { length += 1 + Desc.Length; }
                    if (MusicURL != null) { length += 1 + MusicURL.Length; }
                    if (MediaURL != null) { length += 1 + MediaURL.Length; }
                    return length;
                }
            }

            public ParcelDataBlock() { }
            public ParcelDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RequestResult = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SnapSelection = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    SelfCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OtherCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    PublicCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    AuctionID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ClaimDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ClaimPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    RentPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AABBMin = new LLVector3(bytes, i); i += 12;
                    AABBMax = new LLVector3(bytes, i); i += 12;
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _bitmap = new byte[length];
                    Buffer.BlockCopy(bytes, i, _bitmap, 0, length); i += length;
                    Area = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    Status = (byte)bytes[i++];
                    SimWideMaxPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SimWideTotalPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    MaxPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    TotalPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OwnerPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    GroupPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    OtherPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SelectedPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    ParcelPrimBonus = BitConverter.ToSingle(bytes, i); i += 4;
                    OtherCleanTime = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    ParcelFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    length = (ushort)bytes[i++];
                    _name = new byte[length];
                    Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _desc = new byte[length];
                    Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _musicurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _musicurl, 0, length); i += length;
                    length = (ushort)bytes[i++];
                    _mediaurl = new byte[length];
                    Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
                    MediaID = new LLUUID(bytes, i); i += 16;
                    MediaAutoScale = (byte)bytes[i++];
                    GroupID = new LLUUID(bytes, i); i += 16;
                    PassPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    PassHours = BitConverter.ToSingle(bytes, i); i += 4;
                    Category = (byte)bytes[i++];
                    AuthBuyerID = new LLUUID(bytes, i); i += 16;
                    SnapshotID = new LLUUID(bytes, i); i += 16;
                    UserLocation = new LLVector3(bytes, i); i += 12;
                    UserLookAt = new LLVector3(bytes, i); i += 12;
                    LandingType = (byte)bytes[i++];
                    RegionPushOverride = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RegionDenyAnonymous = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RegionDenyIdentified = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    RegionDenyTransacted = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(RequestResult % 256);
                bytes[i++] = (byte)((RequestResult >> 8) % 256);
                bytes[i++] = (byte)((RequestResult >> 16) % 256);
                bytes[i++] = (byte)((RequestResult >> 24) % 256);
                bytes[i++] = (byte)(SequenceID % 256);
                bytes[i++] = (byte)((SequenceID >> 8) % 256);
                bytes[i++] = (byte)((SequenceID >> 16) % 256);
                bytes[i++] = (byte)((SequenceID >> 24) % 256);
                bytes[i++] = (byte)((SnapSelection) ? 1 : 0);
                bytes[i++] = (byte)(SelfCount % 256);
                bytes[i++] = (byte)((SelfCount >> 8) % 256);
                bytes[i++] = (byte)((SelfCount >> 16) % 256);
                bytes[i++] = (byte)((SelfCount >> 24) % 256);
                bytes[i++] = (byte)(OtherCount % 256);
                bytes[i++] = (byte)((OtherCount >> 8) % 256);
                bytes[i++] = (byte)((OtherCount >> 16) % 256);
                bytes[i++] = (byte)((OtherCount >> 24) % 256);
                bytes[i++] = (byte)(PublicCount % 256);
                bytes[i++] = (byte)((PublicCount >> 8) % 256);
                bytes[i++] = (byte)((PublicCount >> 16) % 256);
                bytes[i++] = (byte)((PublicCount >> 24) % 256);
                bytes[i++] = (byte)(LocalID % 256);
                bytes[i++] = (byte)((LocalID >> 8) % 256);
                bytes[i++] = (byte)((LocalID >> 16) % 256);
                bytes[i++] = (byte)((LocalID >> 24) % 256);
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
                bytes[i++] = (byte)(AuctionID % 256);
                bytes[i++] = (byte)((AuctionID >> 8) % 256);
                bytes[i++] = (byte)((AuctionID >> 16) % 256);
                bytes[i++] = (byte)((AuctionID >> 24) % 256);
                bytes[i++] = (byte)(ClaimDate % 256);
                bytes[i++] = (byte)((ClaimDate >> 8) % 256);
                bytes[i++] = (byte)((ClaimDate >> 16) % 256);
                bytes[i++] = (byte)((ClaimDate >> 24) % 256);
                bytes[i++] = (byte)(ClaimPrice % 256);
                bytes[i++] = (byte)((ClaimPrice >> 8) % 256);
                bytes[i++] = (byte)((ClaimPrice >> 16) % 256);
                bytes[i++] = (byte)((ClaimPrice >> 24) % 256);
                bytes[i++] = (byte)(RentPrice % 256);
                bytes[i++] = (byte)((RentPrice >> 8) % 256);
                bytes[i++] = (byte)((RentPrice >> 16) % 256);
                bytes[i++] = (byte)((RentPrice >> 24) % 256);
                Buffer.BlockCopy(AABBMin.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(AABBMax.GetBytes(), 0, bytes, i, 12); i += 12;
                if(Bitmap == null) { Console.WriteLine("Warning: Bitmap is null, in " + this.GetType()); }
                bytes[i++] = (byte)(Bitmap.Length % 256);
                bytes[i++] = (byte)((Bitmap.Length >> 8) % 256);
                Buffer.BlockCopy(Bitmap, 0, bytes, i, Bitmap.Length); i += Bitmap.Length;
                bytes[i++] = (byte)(Area % 256);
                bytes[i++] = (byte)((Area >> 8) % 256);
                bytes[i++] = (byte)((Area >> 16) % 256);
                bytes[i++] = (byte)((Area >> 24) % 256);
                bytes[i++] = Status;
                bytes[i++] = (byte)(SimWideMaxPrims % 256);
                bytes[i++] = (byte)((SimWideMaxPrims >> 8) % 256);
                bytes[i++] = (byte)((SimWideMaxPrims >> 16) % 256);
                bytes[i++] = (byte)((SimWideMaxPrims >> 24) % 256);
                bytes[i++] = (byte)(SimWideTotalPrims % 256);
                bytes[i++] = (byte)((SimWideTotalPrims >> 8) % 256);
                bytes[i++] = (byte)((SimWideTotalPrims >> 16) % 256);
                bytes[i++] = (byte)((SimWideTotalPrims >> 24) % 256);
                bytes[i++] = (byte)(MaxPrims % 256);
                bytes[i++] = (byte)((MaxPrims >> 8) % 256);
                bytes[i++] = (byte)((MaxPrims >> 16) % 256);
                bytes[i++] = (byte)((MaxPrims >> 24) % 256);
                bytes[i++] = (byte)(TotalPrims % 256);
                bytes[i++] = (byte)((TotalPrims >> 8) % 256);
                bytes[i++] = (byte)((TotalPrims >> 16) % 256);
                bytes[i++] = (byte)((TotalPrims >> 24) % 256);
                bytes[i++] = (byte)(OwnerPrims % 256);
                bytes[i++] = (byte)((OwnerPrims >> 8) % 256);
                bytes[i++] = (byte)((OwnerPrims >> 16) % 256);
                bytes[i++] = (byte)((OwnerPrims >> 24) % 256);
                bytes[i++] = (byte)(GroupPrims % 256);
                bytes[i++] = (byte)((GroupPrims >> 8) % 256);
                bytes[i++] = (byte)((GroupPrims >> 16) % 256);
                bytes[i++] = (byte)((GroupPrims >> 24) % 256);
                bytes[i++] = (byte)(OtherPrims % 256);
                bytes[i++] = (byte)((OtherPrims >> 8) % 256);
                bytes[i++] = (byte)((OtherPrims >> 16) % 256);
                bytes[i++] = (byte)((OtherPrims >> 24) % 256);
                bytes[i++] = (byte)(SelectedPrims % 256);
                bytes[i++] = (byte)((SelectedPrims >> 8) % 256);
                bytes[i++] = (byte)((SelectedPrims >> 16) % 256);
                bytes[i++] = (byte)((SelectedPrims >> 24) % 256);
                ba = BitConverter.GetBytes(ParcelPrimBonus);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = (byte)(OtherCleanTime % 256);
                bytes[i++] = (byte)((OtherCleanTime >> 8) % 256);
                bytes[i++] = (byte)((OtherCleanTime >> 16) % 256);
                bytes[i++] = (byte)((OtherCleanTime >> 24) % 256);
                bytes[i++] = (byte)(ParcelFlags % 256);
                bytes[i++] = (byte)((ParcelFlags >> 8) % 256);
                bytes[i++] = (byte)((ParcelFlags >> 16) % 256);
                bytes[i++] = (byte)((ParcelFlags >> 24) % 256);
                bytes[i++] = (byte)(SalePrice % 256);
                bytes[i++] = (byte)((SalePrice >> 8) % 256);
                bytes[i++] = (byte)((SalePrice >> 16) % 256);
                bytes[i++] = (byte)((SalePrice >> 24) % 256);
                if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
                bytes[i++] = (byte)Name.Length;
                Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
                if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
                bytes[i++] = (byte)Desc.Length;
                Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
                if(MusicURL == null) { Console.WriteLine("Warning: MusicURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MusicURL.Length;
                Buffer.BlockCopy(MusicURL, 0, bytes, i, MusicURL.Length); i += MusicURL.Length;
                if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
                bytes[i++] = (byte)MediaURL.Length;
                Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
                Buffer.BlockCopy(MediaID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = MediaAutoScale;
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(PassPrice % 256);
                bytes[i++] = (byte)((PassPrice >> 8) % 256);
                bytes[i++] = (byte)((PassPrice >> 16) % 256);
                bytes[i++] = (byte)((PassPrice >> 24) % 256);
                ba = BitConverter.GetBytes(PassHours);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = Category;
                Buffer.BlockCopy(AuthBuyerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(UserLocation.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(UserLookAt.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = LandingType;
                bytes[i++] = (byte)((RegionPushOverride) ? 1 : 0);
                bytes[i++] = (byte)((RegionDenyAnonymous) ? 1 : 0);
                bytes[i++] = (byte)((RegionDenyIdentified) ? 1 : 0);
                bytes[i++] = (byte)((RegionDenyTransacted) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- ParcelData --");
                output.AppendLine(String.Format("RequestResult: {0}", RequestResult));
                output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
                output.AppendLine(String.Format("SnapSelection: {0}", SnapSelection));
                output.AppendLine(String.Format("SelfCount: {0}", SelfCount));
                output.AppendLine(String.Format("OtherCount: {0}", OtherCount));
                output.AppendLine(String.Format("PublicCount: {0}", PublicCount));
                output.AppendLine(String.Format("LocalID: {0}", LocalID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
                output.AppendLine(String.Format("AuctionID: {0}", AuctionID));
                output.AppendLine(String.Format("ClaimDate: {0}", ClaimDate));
                output.AppendLine(String.Format("ClaimPrice: {0}", ClaimPrice));
                output.AppendLine(String.Format("RentPrice: {0}", RentPrice));
                output.AppendLine(String.Format("AABBMin: {0}", AABBMin));
                output.AppendLine(String.Format("AABBMax: {0}", AABBMax));
                Helpers.FieldToString(output, Bitmap, "Bitmap");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("Area: {0}", Area));
                output.AppendLine(String.Format("Status: {0}", Status));
                output.AppendLine(String.Format("SimWideMaxPrims: {0}", SimWideMaxPrims));
                output.AppendLine(String.Format("SimWideTotalPrims: {0}", SimWideTotalPrims));
                output.AppendLine(String.Format("MaxPrims: {0}", MaxPrims));
                output.AppendLine(String.Format("TotalPrims: {0}", TotalPrims));
                output.AppendLine(String.Format("OwnerPrims: {0}", OwnerPrims));
                output.AppendLine(String.Format("GroupPrims: {0}", GroupPrims));
                output.AppendLine(String.Format("OtherPrims: {0}", OtherPrims));
                output.AppendLine(String.Format("SelectedPrims: {0}", SelectedPrims));
                output.AppendLine(String.Format("ParcelPrimBonus: {0}", ParcelPrimBonus));
                output.AppendLine(String.Format("OtherCleanTime: {0}", OtherCleanTime));
                output.AppendLine(String.Format("ParcelFlags: {0}", ParcelFlags));
                output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
                Helpers.FieldToString(output, Name, "Name");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, Desc, "Desc");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, MusicURL, "MusicURL");
                output.Append(Environment.NewLine);
                Helpers.FieldToString(output, MediaURL, "MediaURL");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("MediaID: {0}", MediaID));
                output.AppendLine(String.Format("MediaAutoScale: {0}", MediaAutoScale));
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("PassPrice: {0}", PassPrice));
                output.AppendLine(String.Format("PassHours: {0}", PassHours));
                output.AppendLine(String.Format("Category: {0}", Category));
                output.AppendLine(String.Format("AuthBuyerID: {0}", AuthBuyerID));
                output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
                output.AppendLine(String.Format("UserLocation: {0}", UserLocation));
                output.AppendLine(String.Format("UserLookAt: {0}", UserLookAt));
                output.AppendLine(String.Format("LandingType: {0}", LandingType));
                output.AppendLine(String.Format("RegionPushOverride: {0}", RegionPushOverride));
                output.AppendLine(String.Format("RegionDenyAnonymous: {0}", RegionDenyAnonymous));
                output.AppendLine(String.Format("RegionDenyIdentified: {0}", RegionDenyIdentified));
                output.Append(String.Format("RegionDenyTransacted: {0}", RegionDenyTransacted));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ParcelProperties; } }
        public ParcelDataBlock ParcelData;

        public ParcelPropertiesPacket()
        {
            Header = new HighHeader();
            Header.ID = 23;
            Header.Reliable = true;
            ParcelData = new ParcelDataBlock();
        }

        public ParcelPropertiesPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public ParcelPropertiesPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            ParcelData = new ParcelDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += ParcelData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            ParcelData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ParcelProperties ---" + Environment.NewLine;
                output += ParcelData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ChildAgentUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("childagentupdate_agentdata")]
        public class AgentDataBlock
        {
            public ulong RegionHandle;
            public uint ViewerCircuitCode;
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLVector3 AgentPos;
            public LLVector3 AgentVel;
            public LLVector3 Center;
            public LLVector3 Size;
            public LLVector3 AtAxis;
            public LLVector3 LeftAxis;
            public LLVector3 UpAxis;
            public bool ChangedGrid;
            public float Far;
            public float Aspect;
            private byte[] _throttles;
            public byte[] Throttles
            {
                get { return _throttles; }
                set
                {
                    if (value == null) { _throttles = null; return; }
                    if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
                    else { _throttles = new byte[value.Length]; Buffer.BlockCopy(value, 0, _throttles, 0, value.Length); }
                }
            }
            public uint LocomotionState;
            public LLQuaternion HeadRotation;
            public LLQuaternion BodyRotation;
            public uint ControlFlags;
            public float EnergyLevel;
            public byte GodLevel;
            public bool AlwaysRun;
            public LLUUID PreyAgent;
            public byte AgentAccess;
            private byte[] _agenttextures;
            public byte[] AgentTextures
            {
                get { return _agenttextures; }
                set
                {
                    if (value == null) { _agenttextures = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _agenttextures = new byte[value.Length]; Buffer.BlockCopy(value, 0, _agenttextures, 0, value.Length); }
                }
            }
            public LLUUID ActiveGroupID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 208;
                    if (Throttles != null) { length += 1 + Throttles.Length; }
                    if (AgentTextures != null) { length += 2 + AgentTextures.Length; }
                    return length;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    AgentPos = new LLVector3(bytes, i); i += 12;
                    AgentVel = new LLVector3(bytes, i); i += 12;
                    Center = new LLVector3(bytes, i); i += 12;
                    Size = new LLVector3(bytes, i); i += 12;
                    AtAxis = new LLVector3(bytes, i); i += 12;
                    LeftAxis = new LLVector3(bytes, i); i += 12;
                    UpAxis = new LLVector3(bytes, i); i += 12;
                    ChangedGrid = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Far = BitConverter.ToSingle(bytes, i); i += 4;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Aspect = BitConverter.ToSingle(bytes, i); i += 4;
                    length = (ushort)bytes[i++];
                    _throttles = new byte[length];
                    Buffer.BlockCopy(bytes, i, _throttles, 0, length); i += length;
                    LocomotionState = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    HeadRotation = new LLQuaternion(bytes, i, true); i += 12;
                    BodyRotation = new LLQuaternion(bytes, i, true); i += 12;
                    ControlFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    EnergyLevel = BitConverter.ToSingle(bytes, i); i += 4;
                    GodLevel = (byte)bytes[i++];
                    AlwaysRun = (bytes[i++] != 0) ? (bool)true : (bool)false;
                    PreyAgent = new LLUUID(bytes, i); i += 16;
                    AgentAccess = (byte)bytes[i++];
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _agenttextures = new byte[length];
                    Buffer.BlockCopy(bytes, i, _agenttextures, 0, length); i += length;
                    ActiveGroupID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(ViewerCircuitCode % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 8) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 16) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 24) % 256);
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AgentPos.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(AgentVel.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Center.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Size.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(AtAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LeftAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(UpAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)((ChangedGrid) ? 1 : 0);
                ba = BitConverter.GetBytes(Far);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                ba = BitConverter.GetBytes(Aspect);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                if(Throttles == null) { Console.WriteLine("Warning: Throttles is null, in " + this.GetType()); }
                bytes[i++] = (byte)Throttles.Length;
                Buffer.BlockCopy(Throttles, 0, bytes, i, Throttles.Length); i += Throttles.Length;
                bytes[i++] = (byte)(LocomotionState % 256);
                bytes[i++] = (byte)((LocomotionState >> 8) % 256);
                bytes[i++] = (byte)((LocomotionState >> 16) % 256);
                bytes[i++] = (byte)((LocomotionState >> 24) % 256);
                Buffer.BlockCopy(HeadRotation.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(BodyRotation.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)(ControlFlags % 256);
                bytes[i++] = (byte)((ControlFlags >> 8) % 256);
                bytes[i++] = (byte)((ControlFlags >> 16) % 256);
                bytes[i++] = (byte)((ControlFlags >> 24) % 256);
                ba = BitConverter.GetBytes(EnergyLevel);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
                bytes[i++] = GodLevel;
                bytes[i++] = (byte)((AlwaysRun) ? 1 : 0);
                Buffer.BlockCopy(PreyAgent.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = AgentAccess;
                if(AgentTextures == null) { Console.WriteLine("Warning: AgentTextures is null, in " + this.GetType()); }
                bytes[i++] = (byte)(AgentTextures.Length % 256);
                bytes[i++] = (byte)((AgentTextures.Length >> 8) % 256);
                Buffer.BlockCopy(AgentTextures, 0, bytes, i, AgentTextures.Length); i += AgentTextures.Length;
                Buffer.BlockCopy(ActiveGroupID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.AppendLine(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("AgentPos: {0}", AgentPos));
                output.AppendLine(String.Format("AgentVel: {0}", AgentVel));
                output.AppendLine(String.Format("Center: {0}", Center));
                output.AppendLine(String.Format("Size: {0}", Size));
                output.AppendLine(String.Format("AtAxis: {0}", AtAxis));
                output.AppendLine(String.Format("LeftAxis: {0}", LeftAxis));
                output.AppendLine(String.Format("UpAxis: {0}", UpAxis));
                output.AppendLine(String.Format("ChangedGrid: {0}", ChangedGrid));
                output.AppendLine(String.Format("Far: {0}", Far));
                output.AppendLine(String.Format("Aspect: {0}", Aspect));
                Helpers.FieldToString(output, Throttles, "Throttles");
                output.Append(Environment.NewLine);
                output.AppendLine(String.Format("LocomotionState: {0}", LocomotionState));
                output.AppendLine(String.Format("HeadRotation: {0}", HeadRotation));
                output.AppendLine(String.Format("BodyRotation: {0}", BodyRotation));
                output.AppendLine(String.Format("ControlFlags: {0}", ControlFlags));
                output.AppendLine(String.Format("EnergyLevel: {0}", EnergyLevel));
                output.AppendLine(String.Format("GodLevel: {0}", GodLevel));
                output.AppendLine(String.Format("AlwaysRun: {0}", AlwaysRun));
                output.AppendLine(String.Format("PreyAgent: {0}", PreyAgent));
                output.AppendLine(String.Format("AgentAccess: {0}", AgentAccess));
                Helpers.FieldToString(output, AgentTextures, "AgentTextures");
                output.Append(Environment.NewLine);
                output.Append(String.Format("ActiveGroupID: {0}", ActiveGroupID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("childagentupdate_groupdata")]
        public class GroupDataBlock
        {
            public LLUUID GroupID;
            public ulong GroupPowers;
            public bool AcceptNotices;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 25;
                }
            }

            public GroupDataBlock() { }
            public GroupDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GroupID = new LLUUID(bytes, i); i += 16;
                    GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(GroupPowers % 256);
                bytes[i++] = (byte)((GroupPowers >> 8) % 256);
                bytes[i++] = (byte)((GroupPowers >> 16) % 256);
                bytes[i++] = (byte)((GroupPowers >> 24) % 256);
                bytes[i++] = (byte)((GroupPowers >> 32) % 256);
                bytes[i++] = (byte)((GroupPowers >> 40) % 256);
                bytes[i++] = (byte)((GroupPowers >> 48) % 256);
                bytes[i++] = (byte)((GroupPowers >> 56) % 256);
                bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GroupData --");
                output.AppendLine(String.Format("GroupID: {0}", GroupID));
                output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
                output.Append(String.Format("AcceptNotices: {0}", AcceptNotices));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("childagentupdate_animationdata")]
        public class AnimationDataBlock
        {
            public LLUUID Animation;
            public LLUUID ObjectID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 32;
                }
            }

            public AnimationDataBlock() { }
            public AnimationDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    Animation = new LLUUID(bytes, i); i += 16;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(Animation.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AnimationData --");
                output.AppendLine(String.Format("Animation: {0}", Animation));
                output.Append(String.Format("ObjectID: {0}", ObjectID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("childagentupdate_granterblock")]
        public class GranterBlockBlock
        {
            public LLUUID GranterID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 16;
                }
            }

            public GranterBlockBlock() { }
            public GranterBlockBlock(byte[] bytes, ref int i)
            {
                try
                {
                    GranterID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                Buffer.BlockCopy(GranterID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- GranterBlock --");
                output.Append(String.Format("GranterID: {0}", GranterID));
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("childagentupdate_nvpairdata")]
        public class NVPairDataBlock
        {
            private byte[] _nvpairs;
            public byte[] NVPairs
            {
                get { return _nvpairs; }
                set
                {
                    if (value == null) { _nvpairs = null; return; }
                    if (value.Length > 1500) { throw new OverflowException("Value exceeds 1500 characters"); }
                    else { _nvpairs = new byte[value.Length]; Buffer.BlockCopy(value, 0, _nvpairs, 0, value.Length); }
                }
            }

            [XmlIgnore]
            public int Length
            {
                get
                {
                    int length = 0;
                    if (NVPairs != null) { length += 2 + NVPairs.Length; }
                    return length;
                }
            }

            public NVPairDataBlock() { }
            public NVPairDataBlock(byte[] bytes, ref int i)
            {
                int length;
                try
                {
                    length = (ushort)(bytes[i++] + (bytes[i++] << 8));
                    _nvpairs = new byte[length];
                    Buffer.BlockCopy(bytes, i, _nvpairs, 0, length); i += length;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                if(NVPairs == null) { Console.WriteLine("Warning: NVPairs is null, in " + this.GetType()); }
                bytes[i++] = (byte)(NVPairs.Length % 256);
                bytes[i++] = (byte)((NVPairs.Length >> 8) % 256);
                Buffer.BlockCopy(NVPairs, 0, bytes, i, NVPairs.Length); i += NVPairs.Length;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- NVPairData --");
                Helpers.FieldToString(output, NVPairs, "NVPairs");
                return output.ToString();
            }
        }

        /// <exclude/>
        [XmlType("childagentupdate_visualparam")]
        public class VisualParamBlock
        {
            public byte ParamValue;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 1;
                }
            }

            public VisualParamBlock() { }
            public VisualParamBlock(byte[] bytes, ref int i)
            {
                try
                {
                    ParamValue = (byte)bytes[i++];
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = ParamValue;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- VisualParam --");
                output.Append(String.Format("ParamValue: {0}", ParamValue));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChildAgentUpdate; } }
        public AgentDataBlock AgentData;
        public GroupDataBlock[] GroupData;
        public AnimationDataBlock[] AnimationData;
        public GranterBlockBlock[] GranterBlock;
        public NVPairDataBlock[] NVPairData;
        public VisualParamBlock[] VisualParam;

        public ChildAgentUpdatePacket()
        {
            Header = new HighHeader();
            Header.ID = 25;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
            GroupData = new GroupDataBlock[0];
            AnimationData = new AnimationDataBlock[0];
            GranterBlock = new GranterBlockBlock[0];
            NVPairData = new NVPairDataBlock[0];
            VisualParam = new VisualParamBlock[0];
        }

        public ChildAgentUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            AnimationData = new AnimationDataBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationData[j] = new AnimationDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            GranterBlock = new GranterBlockBlock[count];
            for (int j = 0; j < count; j++)
            { GranterBlock[j] = new GranterBlockBlock(bytes, ref i); }
            count = (int)bytes[i++];
            NVPairData = new NVPairDataBlock[count];
            for (int j = 0; j < count; j++)
            { NVPairData[j] = new NVPairDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            VisualParam = new VisualParamBlock[count];
            for (int j = 0; j < count; j++)
            { VisualParam[j] = new VisualParamBlock(bytes, ref i); }
        }

        public ChildAgentUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
            int count = (int)bytes[i++];
            GroupData = new GroupDataBlock[count];
            for (int j = 0; j < count; j++)
            { GroupData[j] = new GroupDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            AnimationData = new AnimationDataBlock[count];
            for (int j = 0; j < count; j++)
            { AnimationData[j] = new AnimationDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            GranterBlock = new GranterBlockBlock[count];
            for (int j = 0; j < count; j++)
            { GranterBlock[j] = new GranterBlockBlock(bytes, ref i); }
            count = (int)bytes[i++];
            NVPairData = new NVPairDataBlock[count];
            for (int j = 0; j < count; j++)
            { NVPairData[j] = new NVPairDataBlock(bytes, ref i); }
            count = (int)bytes[i++];
            VisualParam = new VisualParamBlock[count];
            for (int j = 0; j < count; j++)
            { VisualParam[j] = new VisualParamBlock(bytes, ref i); }
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            length++;
            for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
            length++;
            for (int j = 0; j < AnimationData.Length; j++) { length += AnimationData[j].Length; }
            length++;
            for (int j = 0; j < GranterBlock.Length; j++) { length += GranterBlock[j].Length; }
            length++;
            for (int j = 0; j < NVPairData.Length; j++) { length += NVPairData[j].Length; }
            length++;
            for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; }
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            bytes[i++] = (byte)GroupData.Length;
            for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)AnimationData.Length;
            for (int j = 0; j < AnimationData.Length; j++) { AnimationData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)GranterBlock.Length;
            for (int j = 0; j < GranterBlock.Length; j++) { GranterBlock[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)NVPairData.Length;
            for (int j = 0; j < NVPairData.Length; j++) { NVPairData[j].ToBytes(bytes, ref i); }
            bytes[i++] = (byte)VisualParam.Length;
            for (int j = 0; j < VisualParam.Length; j++) { VisualParam[j].ToBytes(bytes, ref i); }
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChildAgentUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            for (int j = 0; j < GroupData.Length; j++)
            {
                output += GroupData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < AnimationData.Length; j++)
            {
                output += AnimationData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < GranterBlock.Length; j++)
            {
                output += GranterBlock[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < NVPairData.Length; j++)
            {
                output += NVPairData[j].ToString() + Environment.NewLine;
            }
            for (int j = 0; j < VisualParam.Length; j++)
            {
                output += VisualParam[j].ToString() + Environment.NewLine;
            }
            return output;
        }

    }

    /// <exclude/>
    public class ChildAgentAlivePacket : Packet
    {
        /// <exclude/>
        [XmlType("childagentalive_agentdata")]
        public class AgentDataBlock
        {
            public ulong RegionHandle;
            public uint ViewerCircuitCode;
            public LLUUID AgentID;
            public LLUUID SessionID;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 44;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(ViewerCircuitCode % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 8) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 16) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 24) % 256);
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.AppendLine(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.Append(String.Format("SessionID: {0}", SessionID));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChildAgentAlive; } }
        public AgentDataBlock AgentData;

        public ChildAgentAlivePacket()
        {
            Header = new HighHeader();
            Header.ID = 26;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ChildAgentAlivePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ChildAgentAlivePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChildAgentAlive ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class ChildAgentPositionUpdatePacket : Packet
    {
        /// <exclude/>
        [XmlType("childagentpositionupdate_agentdata")]
        public class AgentDataBlock
        {
            public ulong RegionHandle;
            public uint ViewerCircuitCode;
            public LLUUID AgentID;
            public LLUUID SessionID;
            public LLVector3 AgentPos;
            public LLVector3 AgentVel;
            public LLVector3 Center;
            public LLVector3 Size;
            public LLVector3 AtAxis;
            public LLVector3 LeftAxis;
            public LLVector3 UpAxis;
            public bool ChangedGrid;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 129;
                }
            }

            public AgentDataBlock() { }
            public AgentDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
                    AgentID = new LLUUID(bytes, i); i += 16;
                    SessionID = new LLUUID(bytes, i); i += 16;
                    AgentPos = new LLVector3(bytes, i); i += 12;
                    AgentVel = new LLVector3(bytes, i); i += 12;
                    Center = new LLVector3(bytes, i); i += 12;
                    Size = new LLVector3(bytes, i); i += 12;
                    AtAxis = new LLVector3(bytes, i); i += 12;
                    LeftAxis = new LLVector3(bytes, i); i += 12;
                    UpAxis = new LLVector3(bytes, i); i += 12;
                    ChangedGrid = (bytes[i++] != 0) ? (bool)true : (bool)false;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                bytes[i++] = (byte)(RegionHandle % 256);
                bytes[i++] = (byte)((RegionHandle >> 8) % 256);
                bytes[i++] = (byte)((RegionHandle >> 16) % 256);
                bytes[i++] = (byte)((RegionHandle >> 24) % 256);
                bytes[i++] = (byte)((RegionHandle >> 32) % 256);
                bytes[i++] = (byte)((RegionHandle >> 40) % 256);
                bytes[i++] = (byte)((RegionHandle >> 48) % 256);
                bytes[i++] = (byte)((RegionHandle >> 56) % 256);
                bytes[i++] = (byte)(ViewerCircuitCode % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 8) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 16) % 256);
                bytes[i++] = (byte)((ViewerCircuitCode >> 24) % 256);
                Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(AgentPos.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(AgentVel.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Center.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(Size.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(AtAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(LeftAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                Buffer.BlockCopy(UpAxis.GetBytes(), 0, bytes, i, 12); i += 12;
                bytes[i++] = (byte)((ChangedGrid) ? 1 : 0);
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- AgentData --");
                output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
                output.AppendLine(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
                output.AppendLine(String.Format("AgentID: {0}", AgentID));
                output.AppendLine(String.Format("SessionID: {0}", SessionID));
                output.AppendLine(String.Format("AgentPos: {0}", AgentPos));
                output.AppendLine(String.Format("AgentVel: {0}", AgentVel));
                output.AppendLine(String.Format("Center: {0}", Center));
                output.AppendLine(String.Format("Size: {0}", Size));
                output.AppendLine(String.Format("AtAxis: {0}", AtAxis));
                output.AppendLine(String.Format("LeftAxis: {0}", LeftAxis));
                output.AppendLine(String.Format("UpAxis: {0}", UpAxis));
                output.Append(String.Format("ChangedGrid: {0}", ChangedGrid));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.ChildAgentPositionUpdate; } }
        public AgentDataBlock AgentData;

        public ChildAgentPositionUpdatePacket()
        {
            Header = new HighHeader();
            Header.ID = 27;
            Header.Reliable = true;
            AgentData = new AgentDataBlock();
        }

        public ChildAgentPositionUpdatePacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public ChildAgentPositionUpdatePacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            AgentData = new AgentDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += AgentData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            AgentData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- ChildAgentPositionUpdate ---" + Environment.NewLine;
                output += AgentData.ToString() + Environment.NewLine;
            return output;
        }

    }

    /// <exclude/>
    public class SoundTriggerPacket : Packet
    {
        /// <exclude/>
        [XmlType("soundtrigger_sounddata")]
        public class SoundDataBlock
        {
            public LLUUID SoundID;
            public LLUUID OwnerID;
            public LLUUID ObjectID;
            public LLUUID ParentID;
            public ulong Handle;
            public LLVector3 Position;
            public float Gain;

            [XmlIgnore]
            public int Length
            {
                get
                {
                    return 88;
                }
            }

            public SoundDataBlock() { }
            public SoundDataBlock(byte[] bytes, ref int i)
            {
                try
                {
                    SoundID = new LLUUID(bytes, i); i += 16;
                    OwnerID = new LLUUID(bytes, i); i += 16;
                    ObjectID = new LLUUID(bytes, i); i += 16;
                    ParentID = new LLUUID(bytes, i); i += 16;
                    Handle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
                    Position = new LLVector3(bytes, i); i += 12;
                    if (!BitConverter.IsLittleEndian) Array.Reverse(bytes, i, 4);
                    Gain = BitConverter.ToSingle(bytes, i); i += 4;
                }
                catch (Exception)
                {
                    throw new MalformedDataException();
                }
            }

            public void ToBytes(byte[] bytes, ref int i)
            {
                byte[] ba;
                Buffer.BlockCopy(SoundID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
                Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
                bytes[i++] = (byte)(Handle % 256);
                bytes[i++] = (byte)((Handle >> 8) % 256);
                bytes[i++] = (byte)((Handle >> 16) % 256);
                bytes[i++] = (byte)((Handle >> 24) % 256);
                bytes[i++] = (byte)((Handle >> 32) % 256);
                bytes[i++] = (byte)((Handle >> 40) % 256);
                bytes[i++] = (byte)((Handle >> 48) % 256);
                bytes[i++] = (byte)((Handle >> 56) % 256);
                Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
                ba = BitConverter.GetBytes(Gain);
                if(!BitConverter.IsLittleEndian) { Array.Reverse(ba, 0, 4); }
                Buffer.BlockCopy(ba, 0, bytes, i, 4); i += 4;
            }

            public override string ToString()
            {
                StringBuilder output = new StringBuilder();
                output.AppendLine("-- SoundData --");
                output.AppendLine(String.Format("SoundID: {0}", SoundID));
                output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
                output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
                output.AppendLine(String.Format("ParentID: {0}", ParentID));
                output.AppendLine(String.Format("Handle: {0}", Handle));
                output.AppendLine(String.Format("Position: {0}", Position));
                output.Append(String.Format("Gain: {0}", Gain));
                return output.ToString();
            }
        }

        private Header header;
        public override Header Header { get { return header; } set { header = value; } }
        public override PacketType Type { get { return PacketType.SoundTrigger; } }
        public SoundDataBlock SoundData;

        public SoundTriggerPacket()
        {
            Header = new HighHeader();
            Header.ID = 29;
            Header.Reliable = true;
            SoundData = new SoundDataBlock();
        }

        public SoundTriggerPacket(byte[] bytes, ref int i)
        {
            int packetEnd = bytes.Length - 1;
            Header = new HighHeader(bytes, ref i, ref packetEnd);
            SoundData = new SoundDataBlock(bytes, ref i);
        }

        public SoundTriggerPacket(Header head, byte[] bytes, ref int i)
        {
            Header = head;
            SoundData = new SoundDataBlock(bytes, ref i);
        }

        public override byte[] ToBytes()
        {
            int length = 7;
            length += SoundData.Length;;
            if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
            byte[] bytes = new byte[length];
            int i = 0;
            header.ToBytes(bytes, ref i);
            SoundData.ToBytes(bytes, ref i);
            if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
            return bytes;
        }

        public override string ToString()
        {
            string output = "--- SoundTrigger ---" + Environment.NewLine;
                output += SoundData.ToString() + Environment.NewLine;
            return output;
        }

    }

}