private Rance10Object ReadObject(Rance10 rance10, uint addr, int idx)
        {
            if (addr == 0)
            {
                return(null);
            }

            var buf = new byte[64];
            var m   = rance10.ReadMemory(new IntPtr(addr), buf, 8);

            if (!m.Success)
            {
                System.Diagnostics.Debug.Print($"Failed to read memory: {addr:X8}");
                return(null);
            }

            var type = BitConverter.ToInt32(m.Data, 4);

            switch (type)
            {
            case 0: m = rance10.ReadMemory(new IntPtr(addr), buf, Rance10SubObject0.Size); break;

            case 1: m = rance10.ReadMemory(new IntPtr(addr), buf, Rance10SubObject1_Value.Size); break;

            case 2: m = rance10.ReadMemory(new IntPtr(addr), buf, Rance10SubObject2_String.Size); break;

            case 3: m = rance10.ReadMemory(new IntPtr(addr), buf, Rance10SubObject3_Array.Size); break;

            case 4: m = rance10.ReadMemory(new IntPtr(addr), buf, Rance10SubObject4_Class.Size); break;

            case 5: m = rance10.ReadMemory(new IntPtr(addr), buf, Rance10SubObject5.Size); break;

            default: throw new Exception($"Invalid type no: {type} @{addr:X8}");
            }

            if (!m.Success)
            {
                System.Diagnostics.Debug.Print($"Failed to read memory: {addr:X8}");
                return(null);
            }

            var obj = Rance10Object.New(null, (uint)m.Address.ToInt64(), m.Data);

            obj.Seq = idx;

            return(obj);
        }
        private void ReadTables(Rance10 rance10)
        {
            var buf = new byte[256 * 1000];
            var m   = rance10.ReadMemory(new IntPtr(0x007FCBB0), buf, 8);

            if (!m.Success || m.ReadedSize != 8)
            {
                return;
            }

            var mng1 = BitConverter.ToUInt32(m.Data, 0);
            var mng2 = BitConverter.ToUInt32(m.Data, 4);

            m = rance10.ReadMemory(new IntPtr(mng1), buf, 32);

            if (!m.Success || m.ReadedSize != 32)
            {
                return;
            }

            var tbl  = BitConverter.ToUInt32(m.Data, 8);
            var cnt  = BitConverter.ToInt32(m.Data, 20);
            var cnt2 = (cnt + 3) / 4;
            var read = cnt2 * 4;
            var end  = tbl + cnt2 * 4;

            m = rance10.ReadMemory(new IntPtr(tbl), buf, read);

            if (!m.Success || m.ReadedSize != read)
            {
                return;
            }

            ObjectManagerAddress = mng1;
            ObjectCount          = cnt;
            TableCount           = cnt2;
            TableStart           = tbl;
            TableEnd             = (uint)(tbl + cnt2 * 4);
            TableAddresses       = Enumerable.Range(0, TableCount)
                                   .Select(i => BitConverter.ToUInt32(m.Data, i * 4))
                                   .ToArray();
            var objs = new List <uint>(ObjectCount);
            var rem  = cnt;
            var idx  = 0;

            System.Diagnostics.Debug.Print($"ObjectManagerAddress: {ObjectManagerAddress:X8}");
            System.Diagnostics.Debug.Print($"ObjectCount:          {ObjectCount:X8}");
            System.Diagnostics.Debug.Print($"TableCount:           {TableCount:X8}");
            System.Diagnostics.Debug.Print($"TableStart:           {TableStart:X8}");
            System.Diagnostics.Debug.Print($"TableEnd:             {TableEnd:X8}");

            Log.WriteLine("ObjectTable");

            foreach (var i in TableAddresses)
            {
                var tbladdr = TableStart + idx * 4;
                m = rance10.ReadMemory(new IntPtr(i), buf, 16);

                if (m.Success && m.ReadedSize == 16)
                {
                    var a0 = BitConverter.ToUInt32(m.Data, 0);
                    var a1 = BitConverter.ToUInt32(m.Data, 4);
                    var a2 = BitConverter.ToUInt32(m.Data, 8);
                    var a3 = BitConverter.ToUInt32(m.Data, 12);

                    Log.WriteLine("\t#{0}\t{1:X8}->{2:X8}: {3:X8} {4:X8} {5:X8} {6:X8}",
                                  idx++, tbladdr, i, a0, a1, a2, a3);

                    if (rem >= 1)
                    {
                        objs.Add(a0);
                    }
                    if (rem >= 2)
                    {
                        objs.Add(a1);
                    }
                    if (rem >= 3)
                    {
                        objs.Add(a2);
                    }
                    if (rem >= 4)
                    {
                        objs.Add(a3);
                    }
                }
                else
                {
                    throw new Exception();
                }

                rem -= 4;
            }

            Log.Flush();

            ObjectAddresses = objs.ToArray();

            System.Diagnostics.Debug.Assert(ObjectAddresses.Length == ObjectCount);
        }