context: using System;
  using System.IO;
  using System.Text;
  
  namespace wyUpdate.Common
  {
      public static partial class WriteFiles
      {
          public static void WriteInt(Stream fs, byte flag, int num)
          {
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //write the size of the data (Integer = 4bytes)
              fs.Write(BitConverter.GetBytes(4), 0, 4);
  
              //write the integer data
              fs.Write(BitConverter.GetBytes(num), 0, 4);
          }
  
          public static void WriteBool(Stream fs, byte flag, bool val)
          {
              WriteInt(fs, flag, val ? 1 : 0);
          }
  
          public static void WriteLong(Stream fs, byte flag, long val)
          {
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //write the size of the data (Long = 8bytes)
              fs.Write(BitConverter.GetBytes(8), 0, 4);
  
              //write the integer data
              fs.Write(BitConverter.GetBytes(val), 0, 8);
          }
  
          public static void WriteShort(Stream fs, byte flag, short val)
          {
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //write the size of the data (Long = 2bytes)
              fs.Write(BitConverter.GetBytes(2), 0, 4);
  
              // write the integer data
              fs.Write(BitConverter.GetBytes(val), 0, 2);
          }
  
          public static void WriteDateTime(Stream fs, byte flag, DateTime dt)
          {
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //write the size of the data (6 Integers at 4 bytes each = 24bytes)
              fs.Write(BitConverter.GetBytes(24), 0, 4);
  
              //write the DateTime data
  
              //Year
              fs.Write(BitConverter.GetBytes(dt.Year), 0, 4);
              //Month
              fs.Write(BitConverter.GetBytes(dt.Month), 0, 4);
              //Day
              fs.Write(BitConverter.GetBytes(dt.Day), 0, 4);
              //Hour
              fs.Write(BitConverter.GetBytes(dt.Hour), 0, 4);
              //Minute
              fs.Write(BitConverter.GetBytes(dt.Minute), 0, 4);
              //Second
              fs.Write(BitConverter.GetBytes(dt.Second), 0, 4);
          }
  
          public static void WriteString(Stream fs, byte flag, string text)
          {
              if (text == null)
                  text = String.Empty;//fill with an empty string
  
              //the string data to be written
              byte[] tempBytes = Encoding.UTF8.GetBytes(text);
  
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //the byte-length of the string. 
              fs.Write(BitConverter.GetBytes(tempBytes.Length), 0, 4);
  
              //write the string data
              fs.Write(tempBytes, 0, tempBytes.Length);
          }
  
          public static void WriteDeprecatedString(Stream fs, byte flag, string text)
          {
              if (text == null)
                  text = String.Empty;//fill with an empty string
  
              //the string data to be written
              byte[] tempBytes = Encoding.UTF8.GetBytes(text);
              
              //the byte-length of the string. 
              //(Previously I used the string-length, this caused problems for non-bytelong characters)
              byte[] tempLength = BitConverter.GetBytes(tempBytes.Length);
  
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //FIX: I'm storing both the size of the bytes *Twice*. It's stupid.
  
              //write the size of the data
              fs.Write(BitConverter.GetBytes(tempBytes.Length + 4), 0, 4);
  
              //write the string data
              fs.Write(tempLength, 0, 4);
              fs.Write(tempBytes, 0, tempBytes.Length);
          }
  
          public static void WriteByteArray(Stream fs, byte flag, byte[] arr)
          {
              byte[] tempLength = BitConverter.GetBytes(arr.Length);
  
              //write the flag (e.g. 0x01, 0xFF, etc.)
              fs.WriteByte(flag);
  
              //write the byte data
              fs.Write(tempLength, 0, 4);
              fs.Write(arr, 0, arr.Length);
          }
  
          public static void WriteHeader(Stream fs, string Header)
          {
              byte[] arr = Encoding.UTF8.GetBytes(Header);
              fs.Write(arr, 0, arr.Length);
          }
      }
  
      public static partial class ReadFiles
      {
          public static DateTime ReadDateTime(Stream fs)
          {
              //skip the "length of data" int value
              fs.Position += 4;
  
              byte[] tempBytes = new byte[4];
  
              //Year
              ReadWholeArray(fs, tempBytes);
              int year = BitConverter.ToInt32(tempBytes, 0);
  
              //Month
              ReadWholeArray(fs, tempBytes);
              int month = BitConverter.ToInt32(tempBytes, 0);
  
              //Day
              ReadWholeArray(fs, tempBytes);
              int day = BitConverter.ToInt32(tempBytes, 0);
  
              //Hour
              ReadWholeArray(fs, tempBytes);
              int hour = BitConverter.ToInt32(tempBytes, 0);
  
              //Minute
              ReadWholeArray(fs, tempBytes);
              int minute = BitConverter.ToInt32(tempBytes, 0);
  
              //Second
              ReadWholeArray(fs, tempBytes);
              int second = BitConverter.ToInt32(tempBytes, 0);
  
              return new DateTime(year, month, day, hour, minute, second);
          }
  
          public static string ReadString(Stream fs)
          {
              byte[] tempLength = new byte[4];
  
              ReadWholeArray(fs, tempLength);
              byte[] tempBytes = new byte[BitConverter.ToInt32(tempLength, 0)];
              ReadWholeArray(fs, tempBytes);
  
              return Encoding.UTF8.GetString(tempBytes);
          }
  
          public static string ReadDeprecatedString(Stream fs)
          {
              int length = ReadInt(fs);
  
              byte[] tempBytes = new byte[length];
              ReadWholeArray(fs, tempBytes);
              
              return Encoding.UTF8.GetString(tempBytes);
          }
  
          public static byte[] ReadByteArray(Stream fs)
          {
              byte[] tempLength = new byte[4];
  
              ReadWholeArray(fs, tempLength);
              byte[] tempBytes = new byte[BitConverter.ToInt32(tempLength, 0)];
              ReadWholeArray(fs, tempBytes);
  
              return tempBytes;
          }
  
          public static int ReadInt(Stream fs)
          {
              byte[] tempBytes = new byte[4];
  
              //skip the "length of data" int value
              fs.Position += 4;
  
              ReadWholeArray(fs, tempBytes);
              return BitConverter.ToInt32(tempBytes, 0);
          }
  
          public static bool ReadBool(Stream fs)
          {
              return ReadInt(fs) == 1;
          }
  
          //Long (i.e. int64)
          public static long ReadLong(Stream fs)
          {
              byte[] tempBytes = new byte[8];
  
              //skip the "length of data" int value
              fs.Position += 4;
  
              ReadWholeArray(fs, tempBytes);
              return BitConverter.ToInt64(tempBytes, 0);
          }
  
          public static short ReadShort(Stream fs)
          {
              byte[] tempBytes = new byte[2];
  
              //skip the "length of data" int value
              fs.Position += 4;
  
              ReadWholeArray(fs, tempBytes);
  
gt:             return BitConverter.ToInt16(tempBytes, 0);