public override object Read(IReadContext context)
 {
     var b1 = context.ReadByte();
     var b2 = context.ReadByte();
     var charValue = (char) ((b1 & unchecked(0xff)) | ((b2 & unchecked(0xff)) << 8));
     return charValue;
 }

		public override object Read(IReadContext readContext)
		{
			IInternalReadContext context = (IInternalReadContext)readContext;
			int payloadOffset = context.ReadInt();
			if (payloadOffset == 0)
			{
				context.NotifyNullReferenceSkipped();
				return null;
			}
			int savedOffSet = context.Offset();
			try
			{
				ITypeHandler4 typeHandler = ReadTypeHandler(context, payloadOffset);
				if (typeHandler == null)
				{
					return null;
				}
				if (IsPlainObject(typeHandler))
				{
					return ReadPlainObject(readContext);
				}
				SeekSecondaryOffset(context, typeHandler);
				return context.ReadAtCurrentSeekPosition(typeHandler);
			}
			finally
			{
				context.Seek(savedOffSet);
			}
		}

        // #end example

        // #example: Read the StringBuilder
        public object Read(IReadContext readContext)
        {
            int length = readContext.ReadInt();
            byte[] data = new byte[length];
            readContext.ReadBytes(data);
            return new StringBuilder(Encoding.UTF8.GetString(data));
        }

        public object Read(IReadContext context)
        {
        	int classId = context.ReadInt();
			long enumValue = context.ReadLong();
			
			return ToEnum(context, classId, enumValue);
        }

        public override object Eval(GameState state, IReadContext c)
        {
            bool l = (bool)lhs.Eval(state, c);
            // Lazy evaluation
            if (l == true) return true;

            return rhs.Eval(state, c);
        }

		public virtual object Read(IReadContext context)
		{
			object read = StringHandler(context).Read(context);
			if (null == read)
			{
				return null;
			}
			return ConvertString((string)read);
		}

		public override object Read(IReadContext context)
		{
			double value = (double)base.Read(context);
			if (double.IsNaN(value))
			{
				return null;
			}
			return value;
		}

		public override object Read(IReadContext context)
		{
			long value = (long)base.Read(context);
			if (value == long.MaxValue)
			{
				return null;
			}
			return value;
		}

 public override object Read(IReadContext context)
 {
     byte[] bytes = new byte[2];
     context.ReadBytes(bytes);
     return (ushort)(
              bytes[1] & 255 |
             (bytes[0] & 255) << 8
         );
 }

		public override object Read(IReadContext context)
		{
			int i = context.ReadInt();
			if (i == int.MaxValue)
			{
				return null;
			}
			return i;
		}

 public override object Eval(GameState state, IReadContext c)
 {
     var ret = new List<object>();
     foreach (var item in set)
     {
         ret.Add(item.Eval(state, c));
     }
     return ret;
 }

		public override object Read(IReadContext context)
		{
			float value = (float)base.Read(context);
			if (float.IsNaN(value))
			{
				return null;
			}
			return value;
		}

 public override object Read(IReadContext context)
 {
     var value = context.ReadLong();
     if (value == long.MaxValue)
     {
         return PrimitiveNull();
     }
     return new DateTime(value);
 }

		public override object Read(IReadContext context)
		{
			short value = (short)base.Read(context);
			if (value == short.MaxValue)
			{
				return null;
			}
			return value;
		}

        /// <summary>
        /// Initializes a new instance of the <see cref="WriteToReadRepository"/> class.
        /// </summary>
        public WriteToReadRepository(IReadContext readContext)
        {
            if (readContext == null)
            {
                throw new ArgumentNullException(nameof(readContext));
            }

            this.readContext = readContext;
        }

		public override object Read(IReadContext context)
		{
			ByteArrayBuffer buffer = (ByteArrayBuffer)((IInternalReadContext)context).ReadIndirectedBuffer
				();
			if (buffer == null)
			{
				return null;
			}
			return ReadString(context, buffer);
		}

 public override object Read(IReadContext context)
 {
     byte[] bytes = new byte[4];
     context.ReadBytes(bytes);
     return (uint)(
              bytes[3] & 255        | 
             (bytes[2] & 255) << 8  | 
             (bytes[1] & 255) << 16 | 
             (bytes[0] & 255) << 24
         );
 }

 public override object Eval(GameState state, IReadContext c)
 {
     var f = (ICallable)name.Eval(state, c);
     if (f == null) throw new InvalidGameException("Invalid function: " + name);
     object[] args = new object[p.Length];
     //args[0] = c;
     for (int i = 0; i < p.Length; i++)
     {
         args[i] = p[i].Eval(state, c);
     }
     return f.Call(state, Context.NewLocal(state), args);
 }

		protected override void ReadElements(IReadContext context, ArrayInfo info, object
			 array)
		{
			if (array == null)
			{
				return;
			}
			object[] objects = new object[info.ElementCount()];
			ReadInto(context, info, objects);
			ArrayReflector(Container(context)).Shape(objects, 0, array, ((MultidimensionalArrayInfo
				)info).Dimensions(), 0);
		}

		public override object Read(IReadContext context)
		{
			byte ret = context.ReadByte();
			if (ret == True)
			{
				return true;
			}
			if (ret == False)
			{
				return false;
			}
			return null;
		}