context: //
  // PlistCS Property List (plist) serialization and parsing library.
  //
  // https://github.com/animetrics/PlistCS
  //
  // Copyright (c) 2011 Animetrics Inc. (marc@animetrics.com)
  //
  // Permission is hereby granted, free of charge, to any person obtaining a copy
  // of this software and associated documentation files (the "Software"), to deal
  // in the Software without restriction, including without limitation the rights
  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  // copies of the Software, and to permit persons to whom the Software is
  // furnished to do so, subject to the following conditions:
  //
  // The above copyright notice and this permission notice shall be included in
  // all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  // THE SOFTWARE.
  
  
  using System;
  using System.Collections;
  using System.Collections.Generic;
  using System.IO;
  using System.Text;
  using System.Xml;
  
  namespace WGestures.Common.Config
  {
  	internal static class Plist
  	{
  		private static List<int> offsetTable = new List<int>();
  		private static List<byte> objectTable = new List<byte>();
  		private static int refCount;
  		private static int objRefSize;
  		private static int offsetByteSize;
  		private static long offsetTableOffset;
  
  		#region Public Functions
  
  		public static object readPlist(string path)
  		{
  			using (FileStream f = new FileStream(path, FileMode.Open, FileAccess.Read))
  			{
  				return readPlist(f, plistType.Auto);
  			}
  		}
  
  		public static object readPlistSource(string source)
  		{
  			return readPlist(System.Text.Encoding.UTF8.GetBytes(source));
  		}
  
  		public static object readPlist(byte[] data)
  		{
  			return readPlist(new MemoryStream(data), plistType.Auto);
  		}
  
  		public static plistType getPlistType(Stream stream)
  		{
  			byte[] magicHeader = new byte[8];
  			stream.Read(magicHeader, 0, 8);
  
  			if (BitConverter.ToInt64(magicHeader, 0) == 3472403351741427810)
  			{
  				return plistType.Binary;
  			}
  			else
  			{
  				return plistType.Xml;
  			}
  		}
  
  		public static object readPlist(Stream stream, plistType type)
  		{
  			if (type == plistType.Auto)
  			{
  				type = getPlistType(stream);
  				stream.Seek(0, SeekOrigin.Begin);
  			}
  
  			if (type == plistType.Binary)
  			{
  				using (BinaryReader reader = new BinaryReader(stream))
  				{
  					byte[] data = reader.ReadBytes((int) reader.BaseStream.Length);
  					return readBinary(data);
  				}
  			}
  			else
  			{
  				XmlDocument xml = new XmlDocument();
  				xml.XmlResolver = null;
  				xml.Load(stream);
  				return readXml(xml);
  			}
  		}
  
  		public static void writeXml(object value, string path)
  		{
  			using (StreamWriter writer = new StreamWriter(path))
  			{
  				writer.Write(writeXml(value));
  			}
  		}
  
  		public static void writeXml(object value, Stream stream)
  		{
  			using (StreamWriter writer = new StreamWriter(stream))
  			{
  				writer.Write(writeXml(value));
  			}
  		}
  
  		public static string writeXml(object value)
  		{
  			using (MemoryStream ms = new MemoryStream())
  			{
  				XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
  				xmlWriterSettings.Encoding = new System.Text.UTF8Encoding(false);
  				xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document;
  				xmlWriterSettings.Indent = true;
  
  				using (XmlWriter xmlWriter = XmlWriter.Create(ms, xmlWriterSettings))
  				{
  					xmlWriter.WriteStartDocument();
  					//xmlWriter.WriteComment("DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" " + "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\"");
  					xmlWriter.WriteDocType("plist", "-//Apple Computer//DTD PLIST 1.0//EN", "http://www.apple.com/DTDs/PropertyList-1.0.dtd", null);
  					xmlWriter.WriteStartElement("plist");
  					xmlWriter.WriteAttributeString("version", "1.0");
  					compose(value, xmlWriter);
  					xmlWriter.WriteEndElement();
  					xmlWriter.WriteEndDocument();
  					xmlWriter.Flush();
  					xmlWriter.Close();
  					return System.Text.Encoding.UTF8.GetString(ms.ToArray());
  				}
  			}
  		}
  
  		public static void writeBinary(object value, string path)
  		{
  			using (BinaryWriter writer = new BinaryWriter(new FileStream(path, FileMode.Create)))
  			{
  				writer.Write(writeBinary(value));
  			}
  		}
  
  		public static void writeBinary(object value, Stream stream)
  		{
  			using (BinaryWriter writer = new BinaryWriter(stream))
  			{
  				writer.Write(writeBinary(value));
  			}
  		}
  
  		public static byte[] writeBinary(object value)
  		{
  			offsetTable.Clear();
  			objectTable.Clear();
  			refCount = 0;
  			objRefSize = 0;
  			offsetByteSize = 0;
  			offsetTableOffset = 0;
  
  			//Do not count the root node, subtract by 1
  			int totalRefs = countObject(value) - 1;
  
  			refCount = totalRefs;
  
  			objRefSize = RegulateNullBytes(BitConverter.GetBytes(refCount)).Length;
  
  			composeBinary(value);
  
  			writeBinaryString("bplist00", false);
  
  			offsetTableOffset = (long)objectTable.Count;
  
  			offsetTable.Add(objectTable.Count - 8);
  
  			offsetByteSize = RegulateNullBytes(BitConverter.GetBytes(offsetTable[offsetTable.Count-1])).Length;
  
  			List<byte> offsetBytes = new List<byte>();
  
  			offsetTable.Reverse();
  
  			for (int i = 0; i < offsetTable.Count; i++)
  			{
  				offsetTable[i] = objectTable.Count - offsetTable[i];
  				byte[] buffer = RegulateNullBytes(BitConverter.GetBytes(offsetTable[i]), offsetByteSize);
  				Array.Reverse(buffer);
  				offsetBytes.AddRange(buffer);
  			}
  
  			objectTable.AddRange(offsetBytes);
  
  			objectTable.AddRange(new byte[6]);
  			objectTable.Add(Convert.ToByte(offsetByteSize));
  			objectTable.Add(Convert.ToByte(objRefSize));
  
  			var a = BitConverter.GetBytes((long) totalRefs + 1);
  			Array.Reverse(a);
  			objectTable.AddRange(a);
  
  			objectTable.AddRange(BitConverter.GetBytes((long)0));
  			a = BitConverter.GetBytes(offsetTableOffset);
  			Array.Reverse(a);
  			objectTable.AddRange(a);
  
  			return objectTable.ToArray();
  		}
  
  		#endregion
  
  		#region Private Functions
  
  		private static object readXml(XmlDocument xml)
  		{
  			XmlNode rootNode = xml.DocumentElement.ChildNodes[0];
  			return parse(rootNode);
  		}
  
  		private static object readBinary(byte[] data)
  		{
  			offsetTable.Clear();
  			List<byte> offsetTableBytes = new List<byte>();
  			objectTable.Clear();
  			refCount = 0;
  			objRefSize = 0;
  			offsetByteSize = 0;
  			offsetTableOffset = 0;
  
  			List<byte> bList = new List<byte>(data);
  
  			List<byte> trailer = bList.GetRange(bList.Count - 32, 32);
  
  			parseTrailer(trailer);
  
  			objectTable = bList.GetRange(0, (int)offsetTableOffset);
  
  			offsetTableBytes = bList.GetRange((int)offsetTableOffset, bList.Count - (int)offsetTableOffset - 32);
  
  			parseOffsetTable(offsetTableBytes);
  
  			return parseBinary(0);
  		}
  
  		private static Dictionary<string, object> parseDictionary(XmlNode node)
  		{
  			XmlNodeList children = node.ChildNodes;
  			if (children.Count % 2 != 0)
  			{
  				throw new DataMisalignedException("Dictionary elements must have an even number of child nodes");
  			}
  
  			Dictionary<string, object> dict = new Dictionary<string, object>();
  
  			for (int i = 0; i < children.Count; i += 2)
  			{
  				XmlNode keynode = children[i];
  				XmlNode valnode = children[i + 1];
  
  				if (keynode.Name != "key")
  				{
  					throw new ApplicationException("expected a key node");
  				}
  
  				object result = parse(valnode);
  
  				if (result != null)
  				{
  					dict.Add(keynode.InnerText, result);
  				}
  			}
  
  			return dict;
  		}
  
  		private static List<object> parseArray(XmlNode node)
  		{
  			List<object> array = new List<object>();
  
  			foreach (XmlNode child in node.ChildNodes)
  			{
  				object result = parse(child);
  				if (result != null)
  				{
  					array.Add(result);
  				}
  			}
  
  			return array;
  		}
  
  		private static void composeArray(List<object> value, XmlWriter writer)
  		{
  			writer.WriteStartElement("array");
  			foreach (object obj in value)
  			{
  				compose(obj, writer);
  			}
  			writer.WriteEndElement();
  		}
  
  		private static object parse(XmlNode node)
  		{
  			switch (node.Name)
  			{
  			case "dict":
  				return parseDictionary(node);
  			case "array":
  				return parseArray(node);
  			case "string":
  				return node.InnerText;
  			case "integer":
  				// int result;
  				//int.TryParse(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo, out result);
  				return Convert.ToInt32(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo);
  			case "real":
  				return Convert.ToDouble(node.InnerText,System.Globalization.NumberFormatInfo.InvariantInfo);
  			case "false":
  				return false;
  			case "true":
  				return true;
  			case "null":
  				return null;
  			case "date":
  				return XmlConvert.ToDateTime(node.InnerText, XmlDateTimeSerializationMode.Utc);
  			case "data":
  				return Convert.FromBase64String(node.InnerText);
  			}
  
  			throw new ApplicationException(String.Format("Plist Node `{0}' is not supported", node.Name));
  		}
  
  		private static void compose(object value, XmlWriter writer)
  		{
  
  			if (value == null || value is string)
  			{
  				writer.WriteElementString("string", value as string);
  			}
  			else if (value is int || value is long)
  			{
  				writer.WriteElementString("integer", ((int)value).ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
  			}
  			else if (value is System.Collections.Generic.Dictionary<string, object> ||
  				value.GetType().ToString().StartsWith("System.Collections.Generic.Dictionary`2[System.String"))
  			{
  				//Convert to Dictionary<string, object>
  				Dictionary<string, object> dic = value as Dictionary<string, object>;
  				if (dic == null)
  				{
  					dic = new Dictionary<string, object>();
  					IDictionary idic = (IDictionary)value;
  					foreach (var key in idic.Keys)
  					{
  						dic.Add(key.ToString(), idic[key]);
  					}
  				}
  				writeDictionaryValues(dic, writer);
  			}
  			else if (value is List<object>)
  			{
  				composeArray((List<object>)value, writer);
  			}
  			else if (value is byte[])
  			{
  				writer.WriteElementString("data", Convert.ToBase64String((Byte[])value));
  			}
  			else if (value is float || value is double)
  			{
  				writer.WriteElementString("real", ((double)value).ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
  			}
  			else if (value is DateTime)
  			{
  				DateTime time = (DateTime)value;
  				string theString = XmlConvert.ToString(time, XmlDateTimeSerializationMode.Utc);
  				writer.WriteElementString("date", theString);//, "yyyy-MM-ddTHH:mm:ssZ"));
  			}
  			else if (value is bool)
  			{
  				writer.WriteElementString(value.ToString().ToLower(), "");
  			}
  			else
  			{
  				throw new Exception(String.Format("Value type '{0}' is unhandled", value.GetType().ToString()));
  			}
  		}
  
  		private static void writeDictionaryValues(Dictionary<string, object> dictionary, XmlWriter writer)
  		{
  			writer.WriteStartElement("dict");
  			foreach (string key in dictionary.Keys)
  			{
  				object value = dictionary[key];
  				writer.WriteElementString("key", key);
  				compose(value, writer);
  			}
  			writer.WriteEndElement();
  		}
  
  		private static int countObject(object value)
  		{
  			int count = 0;
  			switch (value.GetType().ToString())
  			{
  			case "System.Collections.Generic.Dictionary`2[System.String,System.Object]":
  				Dictionary<string, object> dict = (Dictionary<string, object>)value;
  				foreach (string key in dict.Keys)
  				{
  					count += countObject(dict[key]);
  				}
  				count += dict.Keys.Count;
  				count++;
  				break;
  			case "System.Collections.Generic.List`1[System.Object]":
  				List<object> list = (List<object>)value;
  				foreach (object obj in list)
  				{
  					count += countObject(obj);
  				}
  				count++;
  				break;
  			default:
  				count++;
  				break;
  			}
  			return count;
  		}
  
  		private static byte[] writeBinaryDictionary(Dictionary<string, object> dictionary)
  		{
  			List<byte> buffer = new List<byte>();
  			List<byte> header = new List<byte>();
  			List<int> refs = new List<int>();
  			for (int i = dictionary.Count - 1; i >= 0; i--)
  			{
  				var o = new object[dictionary.Count];
  				dictionary.Values.CopyTo(o, 0);
  				composeBinary(o[i]);
  				offsetTable.Add(objectTable.Count);
  				refs.Add(refCount);
  				refCount--;
  			}
  			for (int i = dictionary.Count - 1; i >= 0; i--)
  			{
  				var o = new string[dictionary.Count];
  				dictionary.Keys.CopyTo(o, 0);
  				composeBinary(o[i]);//);
  				offsetTable.Add(objectTable.Count);
  				refs.Add(refCount);
  				refCount--;
  			}
  
  			if (dictionary.Count < 15)
  			{
  				header.Add(Convert.ToByte(0xD0 | Convert.ToByte(dictionary.Count)));
  			}
  			else
  			{
  				header.Add(0xD0 | 0xf);
  				header.AddRange(writeBinaryInteger(dictionary.Count, false));
  			}
  
  
  			foreach (int val in refs)
  			{
  				byte[] refBuffer = RegulateNullBytes(BitConverter.GetBytes(val), objRefSize);
  				Array.Reverse(refBuffer);
  				buffer.InsertRange(0, refBuffer);
  			}
  
  			buffer.InsertRange(0, header);
  
  
  			objectTable.InsertRange(0, buffer);
  
  			return buffer.ToArray();
  		}
  
  		private static byte[] composeBinaryArray(List<object> objects)
  		{
  			List<byte> buffer = new List<byte>();
  			List<byte> header = new List<byte>();
  			List<int> refs = new List<int>();
  
  			for (int i = objects.Count - 1; i >= 0; i--)
  			{
  				composeBinary(objects[i]);
  				offsetTable.Add(objectTable.Count);
  				refs.Add(refCount);
  				refCount--;
  			}
  
  			if (objects.Count < 15)
  			{
  				header.Add(Convert.ToByte(0xA0 | Convert.ToByte(objects.Count)));
  			}
  			else
  			{
  				header.Add(0xA0 | 0xf);
  				header.AddRange(writeBinaryInteger(objects.Count, false));
  			}
  
  			foreach (int val in refs)
  			{
  				byte[] refBuffer = RegulateNullBytes(BitConverter.GetBytes(val), objRefSize);
  				Array.Reverse(refBuffer);
  				buffer.InsertRange(0, refBuffer);
  			}
  
  			buffer.InsertRange(0, header);
  
  			objectTable.InsertRange(0, buffer);
  
  			return buffer.ToArray();
  		}
  
  		private static byte[] composeBinary(object obj)
  		{
  			byte[] value;
  			switch (obj.GetType().ToString())
  			{
  			case "System.Collections.Generic.Dictionary`2[System.String,System.Object]":
  				value = writeBinaryDictionary((Dictionary<string, object>)obj);
  				return value;
  
  			case "System.Collections.Generic.List`1[System.Object]":
  				value = composeBinaryArray((List<object>)obj);
  				return value;
  
  			case "System.Byte[]":
  				value = writeBinaryByteArray((byte[])obj);
  				return value;
  
  			case "System.Double":
  				value = writeBinaryDouble((double)obj);
  				return value;
  
  			case "System.Int32":
  				value = writeBinaryInteger((int)obj, true);
  				return value;
  
  			case "System.String":
  				value = writeBinaryString((string)obj, true);
  				return value;
  
  			case "System.DateTime":
  				value = writeBinaryDate((DateTime)obj);
  				return value;
  
  			case "System.Boolean":
  				value = writeBinaryBool((bool)obj);
  				return value;
  
  			default:
  				return new byte[0];
  			}
  		}
  
  		public static byte[] writeBinaryDate(DateTime obj)
  		{
  			List<byte> buffer =new List<byte>(RegulateNullBytes(BitConverter.GetBytes(PlistDateConverter.ConvertToAppleTimeStamp(obj)), 8));
  			buffer.Reverse();
  			buffer.Insert(0, 0x33);
  			objectTable.InsertRange(0, buffer);
  			return buffer.ToArray();
  		}
  
  		public static byte[] writeBinaryBool(bool obj)
  		{
  			List<byte> buffer = new List<byte>(new byte[1] { (bool)obj ? (byte)9 : (byte)8 });
  			objectTable.InsertRange(0, buffer);
  			return buffer.ToArray();
  		}
  
  		private static byte[] writeBinaryInteger(int value, bool write)
  		{
  			List<byte> buffer = new List<byte>(BitConverter.GetBytes((long) value));
  			buffer =new List<byte>(RegulateNullBytes(buffer.ToArray()));
  			while (buffer.Count != Math.Pow(2, Math.Log(buffer.Count) / Math.Log(2)))
  				buffer.Add(0);
  			int header = 0x10 | (int)(Math.Log(buffer.Count) / Math.Log(2));
  
  			buffer.Reverse();
  
  			buffer.Insert(0, Convert.ToByte(header));
  
  			if (write)
  				objectTable.InsertRange(0, buffer);
  
  			return buffer.ToArray();
  		}
  
  		private static byte[] writeBinaryDouble(double value)
  		{
  			List<byte> buffer =new List<byte>(RegulateNullBytes(BitConverter.GetBytes(value), 4));
  			while (buffer.Count != Math.Pow(2, Math.Log(buffer.Count) / Math.Log(2)))
  				buffer.Add(0);
  			int header = 0x20 | (int)(Math.Log(buffer.Count) / Math.Log(2));
  
  			buffer.Reverse();
  
  			buffer.Insert(0, Convert.ToByte(header));
  
  			objectTable.InsertRange(0, buffer);
  
  			return buffer.ToArray();
  		}
  
  		private static byte[] writeBinaryByteArray(byte[] value)
  		{
  			List<byte> buffer = new List<byte>(value);
  			List<byte> header = new List<byte>();
  			if (value.Length < 15)
  			{
  				header.Add(Convert.ToByte(0x40 | Convert.ToByte(value.Length)));
  			}
  			else
  			{
  				header.Add(0x40 | 0xf);
  				header.AddRange(writeBinaryInteger(buffer.Count, false));
  			}
  
  			buffer.InsertRange(0, header);
  
  			objectTable.InsertRange(0, buffer);
  
  			return buffer.ToArray();
  		}
  
  		private static byte[] writeBinaryString(string value, bool head)
  		{
  			List<byte> buffer = new List<byte>();
  			List<byte> header = new List<byte>();
  			foreach (char chr in value.ToCharArray())
  				buffer.Add(Convert.ToByte(chr));
  
  			if (head)
  			{
  				if (value.Length < 15)
  				{
  					header.Add(Convert.ToByte(0x50 | Convert.ToByte(value.Length)));
  				}
  				else
  				{
  					header.Add(0x50 | 0xf);
  					header.AddRange(writeBinaryInteger(buffer.Count, false));
  				}
  			}
  
  			buffer.InsertRange(0, header);
  
  			objectTable.InsertRange(0, buffer);
  
  			return buffer.ToArray();
  		}
  
  		private static byte[] RegulateNullBytes(byte[] value)
  		{
  			return RegulateNullBytes(value, 1);
  		}
  
  		private static byte[] RegulateNullBytes(byte[] value, int minBytes)
  		{
  			Array.Reverse(value);
  			List<byte> bytes = new List<byte>(value);
  			for (int i = 0; i < bytes.Count; i++)
  			{
  				if (bytes[i] == 0 && bytes.Count > minBytes)
  				{
  					bytes.Remove(bytes[i]);
  					i--;
  				}
  				else
  					break;
  			}
  
  			if (bytes.Count < minBytes)
  			{
  				int dist = minBytes - bytes.Count;
  				for (int i = 0; i < dist; i++)
  					bytes.Insert(0, 0);
  			}
  
  			value = bytes.ToArray();
  			Array.Reverse(value);
  			return value;
  		}
  
  		private static void parseTrailer(List<byte> trailer)
  		{
  			offsetByteSize = BitConverter.ToInt32(RegulateNullBytes(trailer.GetRange(6, 1).ToArray(), 4), 0);
  			objRefSize = BitConverter.ToInt32(RegulateNullBytes(trailer.GetRange(7, 1).ToArray(), 4), 0);
  			byte[] refCountBytes = trailer.GetRange(12, 4).ToArray();
  			Array.Reverse(refCountBytes);
  			refCount = BitConverter.ToInt32(refCountBytes, 0);
  			byte[] offsetTableOffsetBytes = trailer.GetRange(24, 8).ToArray();
  			Array.Reverse(offsetTableOffsetBytes);
  			offsetTableOffset = BitConverter.ToInt64(offsetTableOffsetBytes, 0);
  		}
  
  		private static void parseOffsetTable(List<byte> offsetTableBytes)
  		{
  			for (int i = 0; i < offsetTableBytes.Count; i += offsetByteSize)
  			{
  				byte[] buffer = offsetTableBytes.GetRange(i, offsetByteSize).ToArray();
  				Array.Reverse(buffer);
  				offsetTable.Add(BitConverter.ToInt32(RegulateNullBytes(buffer, 4), 0));
  			}
  		}
  
  		private static object parseBinaryDictionary(int objRef)
  		{
  			Dictionary<string, object> buffer = new Dictionary<string, object>();
  			List<int> refs = new List<int>();
  			int refCount = 0;
  
  			int refStartPosition;
  			refCount = getCount(offsetTable[objRef], out refStartPosition);
  
  
  			if (refCount < 15)
  				refStartPosition = offsetTable[objRef] + 1;
  			else
  				refStartPosition = offsetTable[objRef] + 2 + RegulateNullBytes(BitConverter.GetBytes(refCount), 1).Length;
  
  			for (int i = refStartPosition; i < refStartPosition + refCount * 2 * objRefSize; i += objRefSize)
  			{
  				byte[] refBuffer = objectTable.GetRange(i, objRefSize).ToArray();
  				Array.Reverse(refBuffer);
  				refs.Add(BitConverter.ToInt32(RegulateNullBytes(refBuffer, 4), 0));
  			}
  
  			for (int i = 0; i < refCount; i++)
  			{
  				buffer.Add((string)parseBinary(refs[i]), parseBinary(refs[i + refCount]));
  			}
  
  			return buffer;
  		}
  
  		private static object parseBinaryArray(int objRef)
  		{
  			List<object> buffer = new List<object>();
  			List<int> refs = new List<int>();
  			int refCount = 0;
  
  			int refStartPosition;
  			refCount = getCount(offsetTable[objRef], out refStartPosition);
  
  
  			if (refCount < 15)
  				refStartPosition = offsetTable[objRef] + 1;
  			else
  				//The following integer has a header aswell so we increase the refStartPosition by two to account for that.
  				refStartPosition = offsetTable[objRef] + 2 + RegulateNullBytes(BitConverter.GetBytes(refCount), 1).Length;
  
  			for (int i = refStartPosition; i < refStartPosition + refCount * objRefSize; i += objRefSize)
  			{
  				byte[] refBuffer = objectTable.GetRange(i, objRefSize).ToArray();
  				Array.Reverse(refBuffer);
  				refs.Add(BitConverter.ToInt32(RegulateNullBytes(refBuffer, 4), 0));
  			}
  
  			for (int i = 0; i < refCount; i++)
  			{
  				buffer.Add(parseBinary(refs[i]));
  			}
  
  			return buffer;
  		}
  
  		private static int getCount(int bytePosition, out int newBytePosition)
  		{
  			byte headerByte = objectTable[bytePosition];
  			byte headerByteTrail = Convert.ToByte(headerByte & 0xf);
  			int count;
  			if (headerByteTrail < 15)
  			{
  				count = headerByteTrail;
  
gt: 				newBytePosition = bytePosition + 1;