diff --git a/OpenSim/OpenSim.RegionServer/world/ParcelManager.cs b/OpenSim/OpenSim.RegionServer/world/ParcelManager.cs
new file mode 100644
index 0000000000..7cc39ffc9f
--- /dev/null
+++ b/OpenSim/OpenSim.RegionServer/world/ParcelManager.cs
@@ -0,0 +1,658 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using libsecondlife;
+using libsecondlife.Packets;
+
+namespace OpenSim.world
+{
+    public delegate void ParcelPropertiesRequest(int start_x, int start_y, int end_x, int end_y, int sequence_id, bool snap_selection, ClientView remote_client);
+    
+    #region Enums
+    public enum ParcelFlags : uint
+    {
+        /// <summary>No flags set</summary>
+        None = 0,
+        /// <summary>Allow avatars to fly (a client-side only restriction)</summary>
+        AllowFly = 1 << 0,
+        /// <summary>Allow foreign scripts to run</summary>
+        AllowOtherScripts = 1 << 1,
+        /// <summary>This parcel is for sale</summary>
+        ForSale = 1 << 2,
+        /// <summary>Allow avatars to create a landmark on this parcel</summary>
+        AllowLandmark = 1 << 3,
+        /// <summary>Allows all avatars to edit the terrain on this parcel</summary>
+        AllowTerraform = 1 << 4,
+        /// <summary>Avatars have health and can take damage on this parcel.
+        /// If set, avatars can be killed and sent home here</summary>
+        AllowDamage = 1 << 5,
+        /// <summary>Foreign avatars can create objects here</summary>
+        CreateObjects = 1 << 6,
+        /// <summary>All objects on this parcel can be purchased</summary>
+        ForSaleObjects = 1 << 7,
+        /// <summary>Access is restricted to a group</summary>
+        UseAccessGroup = 1 << 8,
+        /// <summary>Access is restricted to a whitelist</summary>
+        UseAccessList = 1 << 9,
+        /// <summary>Ban blacklist is enabled</summary>
+        UseBanList = 1 << 10,
+        /// <summary>Unknown</summary>
+        UsePassList = 1 << 11,
+        /// <summary>List this parcel in the search directory</summary>
+        ShowDirectory = 1 << 12,
+        /// <summary>Unknown</summary>
+        AllowDeedToGroup = 1 << 13,
+        /// <summary>Unknown</summary>
+        ContributeWithDeed = 1 << 14,
+        /// <summary>Restrict sounds originating on this parcel to the 
+        /// parcel boundaries</summary>
+        SoundLocal = 1 << 15,
+        /// <summary>Objects on this parcel are sold when the land is 
+        /// purchsaed</summary>
+        SellParcelObjects = 1 << 16,
+        /// <summary>Allow this parcel to be published on the web</summary>
+        AllowPublish = 1 << 17,
+        /// <summary>The information for this parcel is mature content</summary>
+        MaturePublish = 1 << 18,
+        /// <summary>The media URL is an HTML page</summary>
+        UrlWebPage = 1 << 19,
+        /// <summary>The media URL is a raw HTML string</summary>
+        UrlRawHtml = 1 << 20,
+        /// <summary>Restrict foreign object pushes</summary>
+        RestrictPushObject = 1 << 21,
+        /// <summary>Ban all non identified/transacted avatars</summary>
+        DenyAnonymous = 1 << 22,
+        /// <summary>Ban all identified avatars</summary>
+        DenyIdentified = 1 << 23,
+        /// <summary>Ban all transacted avatars</summary>
+        DenyTransacted = 1 << 24,
+        /// <summary>Allow group-owned scripts to run</summary>
+        AllowGroupScripts = 1 << 25,
+        /// <summary>Allow object creation by group members or group 
+        /// objects</summary>
+        CreateGroupObjects = 1 << 26,
+        /// <summary>Allow all objects to enter this parcel</summary>
+        AllowAllObjectEntry = 1 << 27,
+        /// <summary>Only allow group and owner objects to enter this parcel</summary>
+        AllowGroupObjectEntry = 1 << 28,
+    }
+
+    /// <summary>
+    /// Parcel ownership status
+    /// </summary>
+    public enum ParcelStatus : sbyte
+    {
+        /// <summary>Eh?</summary>
+        None = -1,
+        /// <summary>Land is owned</summary>
+        Leased = 0,
+        /// <summary>Land is for sale</summary>
+        LeasePending = 1,
+        /// <summary>Land is public</summary>
+        Abandoned = 2
+    }
+
+    public enum ParcelCategory : sbyte
+    {
+        /// <summary>No assigned category</summary>
+        None = 0,
+        /// <summary></summary>
+        Linden,
+        /// <summary></summary>
+        Adult,
+        /// <summary></summary>
+        Arts,
+        /// <summary></summary>
+        Business,
+        /// <summary></summary>
+        Educational,
+        /// <summary></summary>
+        Gaming,
+        /// <summary></summary>
+        Hangout,
+        /// <summary></summary>
+        Newcomer,
+        /// <summary></summary>
+        Park,
+        /// <summary></summary>
+        Residential,
+        /// <summary></summary>
+        Shopping,
+        /// <summary></summary>
+        Stage,
+        /// <summary></summary>
+        Other,
+        /// <summary>Not an actual category, only used for queries</summary>
+        Any = -1
+    }
+
+    #endregion
+
+    #region ParcelManager Class
+    public class ParcelManager
+    {
+        
+        #region Constants
+        //Parcel types set with flags in ParcelOverlay.
+        //Only one of these can be used. 
+        public static byte PARCEL_TYPE_PUBLIC                   = (byte)0;      //Equals 00000000
+        public static byte PARCEL_TYPE_OWNED_BY_OTHER           = (byte)1;      //Equals 00000001
+        public static byte PARCEL_TYPE_OWNED_BY_GROUP           = (byte)2;      //Equals 00000010
+        public static byte PARCEL_TYPE_OWNED_BY_REQUESTER       = (byte)3;      //Equals 00000011
+        public static byte PARCEL_TYPE_IS_FOR_SALE              = (byte)4;      //Equals 00000100
+        public static byte PARCEL_TYPE_IS_BEING_AUCTIONED       = (byte)5;      //Equals 00000101
+
+
+        //Flags that when set, a border on the given side will be placed
+        //NOTE: North and East is assumable by the west and south sides (if parcel to east has a west border, then I have an east border; etc)
+        //This took forever to figure out -- jeesh. /blame LL for even having to send these
+        public static byte PARCEL_FLAG_PROPERTY_BORDER_WEST     = (byte)64;     //Equals 01000000
+        public static byte PARCEL_FLAG_PROPERTY_BORDER_SOUTH    = (byte)128;    //Equals 10000000
+
+        #endregion
+
+        #region Member Variables
+            private List<Parcel> parcelList;
+            private static World m_world;
+        #endregion
+
+        #region Constructors
+        public ParcelManager(World world)
+        {
+            parcelList = new List<Parcel>();
+            m_world = world;
+            
+            //NOTE: This is temporary until I get to storing the parcels out of memory
+            //This should later only be for new simulators
+            resetSimParcels();
+            Console.WriteLine("Created ParcelManager Object");
+
+
+        }
+        #endregion
+
+        #region Member Functions
+
+        #region Parcel Add/Remove/Get
+        public void addParcel(Parcel new_parcel)
+        {
+            parcelList.Add(new_parcel);
+        }
+        public void removeParcel(Parcel old_parcel)
+        {
+            parcelList.Remove(old_parcel);
+        }
+        public Parcel getParcel(int x, int y)
+        {
+            int searchParcel;
+            for(searchParcel = 0; searchParcel < this.parcelList.Count; searchParcel++)
+            {
+                if(parcelList[searchParcel].containsPoint(x,y))
+                {
+                    return this.parcelList[searchParcel];
+                }
+            }
+            throw new Exception("Error: Parcel not found at point " + x + ", " + y);
+
+        }
+        #endregion
+
+        #region Parcel Modification
+        public bool subdivide(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
+        {
+            //First, lets loop through the points and make sure they are all in the same parcel
+            //Get the parcel at start
+            Parcel startParcel = getParcel(start_x, start_y);
+            if(startParcel == null) return false; //No such parcel at the beginning
+           
+            //Loop through the points
+            try
+            {
+                int totalX = end_x - start_x;
+                int totalY = end_y - start_y;
+                int x, y;
+                for (x = 0; x < totalX; x++)
+                {
+                    for (y = 0; y < totalY; y++)
+                    {
+                        Parcel tempParcel = getParcel(start_x + x, start_y + y);
+                        if (tempParcel == null) return false; //No such parcel at that point
+                        if (tempParcel != startParcel) return false; //Subdividing over 2 parcels; no-no
+                    }
+                }
+            }
+            catch (Exception e)
+            {
+                return false; //Exception. For now, lets skip subdivision
+            }
+
+            //If we are still here, then they are subdividing within one parcel
+            //Check owner
+            if (startParcel.ownerID != attempting_user_id)
+            {
+                return false; //They cant do this!
+            }
+
+            //Lets create a new parcel with bitmap activated at that point (keeping the old parcels info)
+            Parcel newParcel = startParcel;
+            newParcel.setParcelBitmap(Parcel.getSquareParcelBitmap(start_x, start_y, end_x, end_y));
+            
+            //Now, lets set the subdivision area of the original to false
+            int startParcelIndex = parcelList.IndexOf(startParcel);
+            parcelList[startParcelIndex].setParcelBitmap(Parcel.modifyParcelBitmapSquare(parcelList[startParcelIndex].getParcelBitmap(),start_x,start_y,end_x, end_y,false));
+
+            //Now add the new parcel
+            addParcel(newParcel);
+
+            return true;
+        }
+
+        public bool join(int start_x, int start_y, int end_x, int end_y, LLUUID attempting_user_id)
+        {
+            //NOTE: The following only connects the parcels in each corner and not all the parcels that are within the selection box!
+            //This should be fixed later -- somewhat "incomplete code" --Ming
+            Parcel startParcel, endParcel;
+            try
+            {
+                startParcel = getParcel(start_x, start_y);
+                endParcel = getParcel(end_x, end_y);
+            }
+            catch (Exception e)
+            {
+                return false; //Error occured when trying to get the start and end parcels
+            }
+            //Check the parcel owners:
+            if (startParcel.ownerID != endParcel.ownerID)
+            {
+                return false;
+            }
+            if (startParcel.ownerID != attempting_user_id)
+            {
+                //TODO: Group editing stuff. Avatar owner support for now
+                return false;
+            }
+
+            //Same owners! Lets join them
+            //Merge them to startParcel
+            parcelList[parcelList.IndexOf(startParcel)].setParcelBitmap(Parcel.mergeParcelBitmaps(startParcel.getParcelBitmap(),endParcel.getParcelBitmap()));
+
+            //Remove the old parcel
+            parcelList.Remove(endParcel);
+
+            return true;
+
+
+
+        }
+        #endregion
+
+        #region Parcel Updating
+        /// <summary>
+        /// Where we send the ParcelOverlay packet to the client
+        /// </summary>
+        /// <param name="remote_client">The object representing the client</param>
+        public void sendParcelOverlay(ClientView remote_client)
+        {
+            const int PARCEL_BLOCKS_PER_PACKET = 1024;
+            int x, y = 0;
+            byte[] byteArray = new byte[PARCEL_BLOCKS_PER_PACKET];
+            int byteArrayCount = 0;
+            int sequenceID = 0;
+            ParcelOverlayPacket packet;
+
+            for (x = 0; x < 64; x++)
+            {
+                for (y = 0; y < 64; y++)
+                {
+                    byte tempByte = (byte)0; //This represents the byte for the current 4x4
+                    Parcel currentParcelBlock = getParcel(x * 4, y * 4);
+
+                    if (currentParcelBlock.ownerID == remote_client.AgentID)
+                    {
+                        //Owner Flag
+                        tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_OWNED_BY_REQUESTER);
+                    }
+                    else if (currentParcelBlock.salePrice > 0 && (currentParcelBlock.authBuyerID == LLUUID.Zero || currentParcelBlock.authBuyerID == remote_client.AgentID))
+                    {
+                        //Sale Flag
+                        tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_IS_FOR_SALE);
+                    }
+                    else if (currentParcelBlock.ownerID == LLUUID.Zero)
+                    {
+                        //Public Flag
+                        tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_PUBLIC);
+                    }
+                    else
+                    {
+                        //Other Flag
+                        tempByte = Convert.ToByte(tempByte | PARCEL_TYPE_OWNED_BY_OTHER);
+                    }
+
+
+                    //Now for border control
+                    if (x == 0)
+                    {
+                        tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_WEST);
+                    }
+                    else if (getParcel(x - 1, y) != currentParcelBlock)
+                    {
+                        tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_WEST);
+                    }
+
+                    if (y == 0)
+                    {
+                        tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_SOUTH);
+                    }
+                    else if (getParcel(x, y - 1) != currentParcelBlock)
+                    {
+                        tempByte = Convert.ToByte(tempByte | PARCEL_FLAG_PROPERTY_BORDER_SOUTH);
+                    }
+
+                    byteArray[byteArrayCount] = tempByte;
+                    byteArrayCount++;
+                    if (byteArrayCount >= PARCEL_BLOCKS_PER_PACKET)
+                    {
+                        byteArrayCount = 0;
+                        packet = new ParcelOverlayPacket();
+                        packet.ParcelData.Data = byteArray;
+                        packet.ParcelData.SequenceID = sequenceID;
+                        remote_client.OutPacket((Packet)packet);
+                        sequenceID++;
+                        byteArray = new byte[PARCEL_BLOCKS_PER_PACKET];
+                    }
+                }
+            }
+
+            packet = new ParcelOverlayPacket();
+            packet.ParcelData.Data = byteArray;
+            packet.ParcelData.SequenceID = sequenceID; //Eh?
+            remote_client.OutPacket((Packet)packet);
+        }
+        #endregion
+        public void resetSimParcels()
+        {
+            //Remove all the parcels in the sim and add a blank, full sim parcel set to public
+            parcelList.Clear();
+            Parcel fullSimParcel = new Parcel(LLUUID.Zero, false,m_world);
+            fullSimParcel.setParcelBitmap(Parcel.basicFullRegionParcelBitmap());
+            fullSimParcel.parcelName = "Your Sim Parcel";
+            fullSimParcel.parcelDesc = "";
+            LLUUID Agent;
+            int AgentRand = OpenSim.Framework.Utilities.Util.RandomClass.Next(1, 9999);
+            Agent = new LLUUID("99998888-0100-" + AgentRand.ToString("0000") + "-8ec1-0b1d5cd6aead");
+
+            fullSimParcel.ownerID = Agent;
+            fullSimParcel.salePrice = 1;
+            fullSimParcel.parcelFlags = ParcelFlags.ForSale;
+
+            addParcel(fullSimParcel);
+            
+            
+        }
+        #endregion
+    }
+    #endregion
+
+    
+    #region Parcel Class
+    public class Parcel
+    {
+        #region Member Variables
+        private bool[,] parcelBitmap = new bool[64,64];
+        public string parcelName = "";
+        public string parcelDesc = "";
+        public LLUUID ownerID = new LLUUID();
+        public bool isGroupOwned = false;
+        public LLVector3 AABBMin = new LLVector3();
+        public LLVector3 AABBMax = new LLVector3();
+        public int area = 0;
+        public uint auctionID = 0; //Unemplemented. If set to 0, not being auctioned
+        public LLUUID authBuyerID = new LLUUID(); //Unemplemented. Authorized Buyer's UUID
+        public ParcelCategory category = new ParcelCategory(); //Unemplemented. Parcel's chosen category
+        public int claimDate = 0; //Unemplemented
+        public int claimPrice = 0; //Unemplemented
+        public LLUUID groupID = new LLUUID(); //Unemplemented
+        public int groupPrims = 0; //Unemplemented
+        public int salePrice = 0; //Unemeplemented. Parcels price.
+        public ParcelStatus parcelStatus = ParcelStatus.None;
+        public ParcelFlags parcelFlags = ParcelFlags.None;
+
+        private int localID;
+        private static int localIDCount = 0;
+        private World m_world;
+        #endregion
+
+
+        #region Constructors
+        public Parcel(LLUUID owner_id, bool is_group_owned, World world)
+        {
+            m_world = world;
+            ownerID = owner_id;
+            isGroupOwned = is_group_owned;
+
+            localID = localIDCount;
+            localIDCount++;
+
+        }
+        #endregion
+
+
+        #region Member Functions
+
+        #region General Functions
+        public bool containsPoint(int x, int y)
+        {
+            if (x >= 0 && y >= 0 && x <= 256 && x <= 256)
+            {
+                return (this.parcelBitmap[x / 4, y / 4] == true);
+            }
+            else
+            {
+                return false;
+            }
+        }
+        #endregion
+
+
+        #region Packet Request Handling
+        public void sendParcelProperties(int sequence_id, bool snap_selection, ClientView remote_client)
+        {
+
+            ParcelPropertiesPacket updatePacket = new ParcelPropertiesPacket();
+            updatePacket.ParcelData.AABBMax = AABBMax;
+            updatePacket.ParcelData.AABBMin = AABBMin;
+            updatePacket.ParcelData.Area = this.area;
+            updatePacket.ParcelData.AuctionID = this.auctionID; 
+            updatePacket.ParcelData.AuthBuyerID = this.authBuyerID; //unemplemented
+
+            updatePacket.ParcelData.Bitmap = this.convertParcelBitmapToBytes();
+
+            updatePacket.ParcelData.Desc = libsecondlife.Helpers.StringToField(this.parcelDesc);
+            updatePacket.ParcelData.Category = (byte)this.category;
+            updatePacket.ParcelData.ClaimDate = this.claimDate;
+            updatePacket.ParcelData.ClaimPrice = this.claimPrice;
+            updatePacket.ParcelData.GroupID = this.groupID;
+            updatePacket.ParcelData.GroupPrims = this.groupPrims;
+            updatePacket.ParcelData.IsGroupOwned = this.isGroupOwned;
+            updatePacket.ParcelData.LandingType = (byte)0; //unemplemented
+            updatePacket.ParcelData.LocalID = (byte)this.localID;
+            updatePacket.ParcelData.MaxPrims = 1000; //unemplemented
+            updatePacket.ParcelData.MediaAutoScale = (byte)0; //unemplemented
+            updatePacket.ParcelData.MediaID = LLUUID.Zero; //unemplemented
+            updatePacket.ParcelData.MediaURL = Helpers.StringToField(""); //unemplemented
+            updatePacket.ParcelData.MusicURL = Helpers.StringToField(""); //unemplemented
+            updatePacket.ParcelData.Name = Helpers.StringToField(this.parcelName);
+            updatePacket.ParcelData.OtherCleanTime = 0; //unemplemented
+            updatePacket.ParcelData.OtherCount = 0; //unemplemented
+            updatePacket.ParcelData.OtherPrims = 0; //unemplented
+            updatePacket.ParcelData.OwnerID = this.ownerID;
+            updatePacket.ParcelData.OwnerPrims = 0; //unemplemented
+            updatePacket.ParcelData.ParcelFlags = (uint)this.parcelFlags; //unemplemented
+            updatePacket.ParcelData.ParcelPrimBonus = (float)1.0; //unemplemented
+            updatePacket.ParcelData.PassHours = (float)0.0; //unemplemented
+            updatePacket.ParcelData.PassPrice = 0; //unemeplemented
+            updatePacket.ParcelData.PublicCount = 0; //unemplemented
+            updatePacket.ParcelData.RegionDenyAnonymous = false; //unemplemented
+            updatePacket.ParcelData.RegionDenyIdentified = false; //unemplemented
+            updatePacket.ParcelData.RegionDenyTransacted = false; //unemplemented
+            updatePacket.ParcelData.RegionPushOverride = true; //unemplemented
+            updatePacket.ParcelData.RentPrice = 0; //??
+            updatePacket.ParcelData.RequestResult = 0;//??
+            updatePacket.ParcelData.SalePrice = this.salePrice; //unemplemented
+            updatePacket.ParcelData.SelectedPrims = 0; //unemeplemented
+            updatePacket.ParcelData.SelfCount = 0;//unemplemented
+            updatePacket.ParcelData.SequenceID = sequence_id;
+            updatePacket.ParcelData.SimWideMaxPrims = 15000; //unemplemented
+            updatePacket.ParcelData.SimWideTotalPrims = 0; //unemplemented
+            updatePacket.ParcelData.SnapSelection = snap_selection; //Bleh - not important yet
+            updatePacket.ParcelData.SnapshotID = LLUUID.Zero; //Unemplemented
+            updatePacket.ParcelData.Status = (byte)this.parcelStatus; //??
+            updatePacket.ParcelData.TotalPrims = 0; //unemplemented
+            updatePacket.ParcelData.UserLocation = LLVector3.Zero; //unemplemented
+            updatePacket.ParcelData.UserLookAt = LLVector3.Zero; //unemeplemented
+            
+            remote_client.OutPacket((Packet)updatePacket);
+        }
+        #endregion
+
+
+        #region Update Functions
+        private void updateAABBAndAreaValues()
+        {
+            int min_x = 64;
+            int min_y = 64;
+            int max_x = 0;
+            int max_y = 0;
+            int tempArea = 0;
+            int x, y;
+            for (x = 0; x < 64; x++)
+            {
+                for (y = 0; y < 64; y++)
+                {
+                    if (parcelBitmap[x, y] == true)
+                    {
+                        if (min_x > x) min_x = x;
+                        if (min_y > y) min_y = y;
+                        if (max_x < x) max_x = x;
+                        if (max_y < y) max_y = y;
+                        tempArea += 16; //16sqm parcel
+                    }
+                }
+            }
+            this.AABBMin = new LLVector3((float)(min_x * 4), (float)(min_y * 4), m_world.Terrain[(min_x * 4), (min_y * 4)]);
+            this.AABBMax = new LLVector3((float)(max_x * 4), (float)(max_y * 4), m_world.Terrain[(max_x * 4), (max_y * 4)]);
+            this.area = tempArea;
+        }
+        #endregion
+
+
+        #region Parcel Bitmap Functions
+        public void setParcelBitmap(bool[,] bitmap)
+        {
+            if (bitmap.GetLength(0) != 64 || bitmap.GetLength(1) != 64 || bitmap.Rank != 2)
+            {
+                //Throw an exception - The bitmap is not 64x64
+                throw new Exception("Error: Invalid Parcel Bitmap");
+            }
+            else
+            {
+                //Valid: Lets set it
+                this.parcelBitmap = bitmap;
+                updateAABBAndAreaValues();
+            }
+        }
+        public bool[,] getParcelBitmap()
+        {
+            return parcelBitmap;
+        }
+        private byte[] convertParcelBitmapToBytes()
+        {
+            byte[] tempConvertArr = new byte[64 * 64 / 8];
+            byte tempByte = 0;
+            int x, y,i, byteNum = 0;
+            i = 0;
+            for (x = 0; x < 64; x++)
+            {
+                for (y = 0; y < 64; y++)
+                {
+                    tempByte = Convert.ToByte(tempByte | Convert.ToByte(parcelBitmap[x,y]) << (i++ % 8));
+                    if (i % 8 == 0)
+                    {
+                        tempConvertArr[byteNum] = tempByte;
+                        tempByte = (byte)0;
+                        i = 0;
+                        byteNum++;
+                    }
+                }
+            }
+            tempByte.ToString();
+            return tempConvertArr;
+        }
+
+        public static bool[,] basicFullRegionParcelBitmap()
+        {
+            return getSquareParcelBitmap(0, 0, 256, 256);
+        }
+        public static bool[,] getSquareParcelBitmap(int start_x, int start_y, int end_x, int end_y)
+        {
+
+            bool[,] tempBitmap = new bool[64, 64];
+            tempBitmap.Initialize();
+
+            tempBitmap = modifyParcelBitmapSquare(tempBitmap, start_x, start_y, end_x, end_x, true);
+            return tempBitmap;
+        }
+        public static bool[,] modifyParcelBitmapSquare(bool[,] parcel_bitmap, int start_x, int start_y, int end_x, int end_y, bool set_value)
+        {
+            if (parcel_bitmap.GetLength(0) != 64 || parcel_bitmap.GetLength(1) != 64 || parcel_bitmap.Rank != 2)
+            {
+                //Throw an exception - The bitmap is not 64x64
+                throw new Exception("Error: Invalid Parcel Bitmap in modifyParcelBitmapSquare()");
+            }
+
+            int x, y;
+            for (x = 0; x < 64; x++)
+            {
+                for (y = 0; y < 64; y++)
+                {
+                    if (x >= start_x / 4 && x <= end_x / 4
+                        && y >= start_y / 4 && y <= end_y / 4)
+                    {
+                        parcel_bitmap[x, y] = true;
+                    }
+                }
+            }
+            return parcel_bitmap;
+        }
+        public static bool[,] mergeParcelBitmaps(bool[,] bitmap_base, bool[,] bitmap_add)
+        {
+            if (bitmap_base.GetLength(0) != 64 || bitmap_base.GetLength(1) != 64 || bitmap_base.Rank != 2)
+            {
+                //Throw an exception - The bitmap is not 64x64
+                throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_base in mergeParcelBitmaps");
+            }
+            if (bitmap_add.GetLength(0) != 64 || bitmap_add.GetLength(1) != 64 || bitmap_add.Rank != 2)
+            {
+                //Throw an exception - The bitmap is not 64x64
+                throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_add in mergeParcelBitmaps");
+            }
+
+            int x, y;
+            for (x = 0; x < 64; x++)
+            {
+                for (y = 0; y < 64; y++)
+                {
+                    if (bitmap_add[x,y])
+                    {
+                        bitmap_base[x, y] = true;
+                    }
+                }
+            }
+            return bitmap_base;
+        }
+        #endregion
+
+        #endregion
+    }
+    #endregion
+}