DataMuseum.dk Presents historical artifacts from the history of: Rational R1000/400

This is an automatic "excavation" of a thematic subset of artifacts from Datamuseum.dk's BitArchive. See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software.

top - metrics - download

⟦3498879a6⟧ Ada Source

    Length: 29696 (0x7400)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Any, seg_0045ae, separate Object_Info

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─⟦5a81ac88f⟧ »Space Info Vol 1« 
        └─⟦this⟧ 

separate (Object_Info)
package body Any is

    function Is_Empty (These_Objects : in Objects) return Boolean is

        The_Objects : Objects := These_Objects;

    begin
        Directory_Tools.Object.Reset (The_Objects);
        return Directory_Tools.Object.Done (The_Objects);
    end Is_Empty;

    function Number_In (These_Objects : in Objects) return Natural is

        The_Objects : Objects := These_Objects;

        Count : Natural := 0;

    begin
        Directory_Tools.Object.Reset (The_Objects);
        while not Directory_Tools.Object.Done (The_Objects) loop
            Count := Count + 1;
            Directory_Tools.Object.Next (The_Objects);
        end loop;
        Directory_Tools.Object.Reset (The_Objects);
        return Count;
    end Number_In;

    function Classes_Equal
                (This_Object : in Object;
                 This_Class  : in Directory_Tools.Object.Class_Enumeration)
                return Boolean is
    begin
        return Directory_Tools.Object.Equal
                  (Directory_Tools.Object.Class (This_Object), This_Class);
    end Classes_Equal;

    function Subclasses_Equal (This_Object   : in Object;
                               This_Subclass : in Standard.Directory.Subclass)
                              return Boolean is

        function "=" (This_Subclass : in Standard.Directory.Subclass;
                      That_Subclass : in Standard.Directory.Subclass)
                     return Boolean renames Standard.Directory."=";

        function "=" (This_Error_Status : in Standard.Directory.Error_Status;
                      That_Error_Status : in Standard.Directory.Error_Status)
                     return Boolean renames Standard.Directory."=";

        The_Object : Standard.Directory.Object;
        The_Status : Standard.Directory.Error_Status;

    begin
        Directory_Tools.Object.Low_Level.Get_Object
           (This_Object, The_Object, The_Status);
        return (The_Status = Standard.Directory.Successful) and then
                  (Standard.Directory.Get_Subclass (The_Object) =
                   This_Subclass);
    end Subclasses_Equal;

    function Is_Good (This_Object : in Object) return Boolean is
    begin
        return not Directory_Tools.Object.Is_Bad (This_Object);
    end Is_Good;

    function Is_Bad (This_Object : in Object) return Boolean is
    begin
        return Directory_Tools.Object.Is_Bad (This_Object);
    end Is_Bad;

    function Is_Library (This_Object : in Object) return Boolean is
    begin
        return Directory_Tools.Library_Object.Is_Library (This_Object);
    end Is_Library;

    function Is_Directory (This_Object : in Object) return Boolean is
    begin
        return Directory_Tools.Library_Object.Is_Directory (This_Object);
    end Is_Directory;

    function Is_World (This_Object : in Object) return Boolean is
    begin
        return Directory_Tools.Library_Object.Is_World (This_Object);
    end Is_World;

    function Is_Simple_World (This_Object : in Object) return Boolean is
    begin
        return Any.Is_World (This_Object) and then
                  not Any.Is_Subsystem (This_Object) and then
                  not Any.Is_View (This_Object);
    end Is_Simple_World;

    function Is_Model_World (This_Object : in Object) return Boolean is
    begin
        return  
           (Directory_Tools.  
            Naming.Prefix (Directory_Tools.  
                           Naming.Full_Name (This_Object)) = "!MODEL") and then  
           Any.Is_Simple_World (This_Object);
    end Is_Model_World;

    function Is_Root (This_Object : in Object) return Boolean is
    begin
        return Directory_Tools.Naming.Full_Name (This_Object) = "!";
    end Is_Root;

    function Is_Subsystem (This_Object : in Object) return Boolean is
    begin
        return Any.Subclasses_Equal
                  (This_Object, Object_Subclass.Subsystem_Subclass) or else
               Any.Subclasses_Equal
                  (This_Object, Object_Subclass.
                                   Spec_Load_Subsystem_Subclass) or else  
               Any.Subclasses_Equal
                  (This_Object, Object_Subclass.Combined_Subsystem_Subclass);
    end Is_Subsystem;

    function Is_View (This_Object : in Object) return Boolean is
    begin
        return Any.Subclasses_Equal (This_Object,
                                     Object_Subclass.Spec_View_Subclass) or else
               Any.Subclasses_Equal (This_Object,
                                     Object_Subclass.Load_View_Subclass) or else
               Any.Subclasses_Equal (This_Object,
                                     Object_Subclass.Combined_View_Subclass);
    end Is_View;

    function Is_Spec_View (This_Object : in Object) return Boolean is
    begin
        return Any.Subclasses_Equal (This_Object,
                                     Object_Subclass.Spec_View_Subclass);
    end Is_Spec_View;

    function Is_Load_View (This_Object : in Object) return Boolean is
    begin
        return Any.Subclasses_Equal (This_Object,
                                     Object_Subclass.Load_View_Subclass);
    end Is_Load_View;

    function Is_Working_Load_View (This_Object : in Object) return Boolean is

        -- Since there is no Working_View subclass, we
        -- need to test if the name of the object ends in
        -- "_WORKING".

        Suffix : constant String := "_WORKING";

        Name : constant String :=
           Directory_Tools.Naming.Full_Name (This_Object);

    begin  
        return Any.Is_Load_View (This_Object) and then
                  not Any.Is_Code_Only_Load_View (This_Object) and then
                  (Name (Name'Last - Suffix'Length + 1 .. Name'Last) = Suffix);
    exception
        when others =>
            return False;

    end Is_Working_Load_View;

    function Is_Released_Load_View (This_Object : in Object) return Boolean is
    begin
        return Any.Is_Load_View (This_Object) and then
                  not Any.Is_Working_Load_View (This_Object) and then
                  not Any.Is_Code_Only_Load_View (This_Object);
    end Is_Released_Load_View;

    function Is_Code_Only_Load_View (This_Object : in Object) return Boolean is

        -- Since there is no Code_View subclass, we need
        -- to test for the presence or absence of a code
        -- database.

    begin
        return Any.Is_Load_View (This_Object) and then
                  Any.Is_Good (Directory_Tools.Naming.Resolution
                                  (Directory_Tools.Naming.Full_Name
                                      (This_Object) & ".CODE_DATABASE"));
    end Is_Code_Only_Load_View;

    function Is_Combined_View (This_Object : in Object) return Boolean is
    begin
        return Any.Subclasses_Equal (This_Object,
                                     Object_Subclass.Combined_View_Subclass);
    end Is_Combined_View;

    function Is_Units_Directory_Of_View
                (This_Object : in Object) return Boolean is
    begin  
        return Any.Is_Directory (This_Object) and then
                  (Directory_Tools.Naming.Full_Name (This_Object) =
                   Directory_Tools.Naming.Full_Name
                      (View_Containing (This_Object, Transitive => False)) &
                   ".UNITS");
    end Is_Units_Directory_Of_View;

    function Is_Simple_Object (This_Object : in Object) return Boolean is
    begin
        return Any.Is_Good (This_Object) and then  
                  not Any.Is_Library (This_Object);
    end Is_Simple_Object;

    function Is_Ada_Unit (This_Object : in Object) return Boolean is
    begin
        return Any.Classes_Equal (This_Object,
                                  Directory_Tools.Object.Ada_Class);
    end Is_Ada_Unit;

    function Is_File (This_Object : in Object) return Boolean is
    begin
        return Any.Classes_Equal (This_Object,
                                  Directory_Tools.Object.File_Class);
    end Is_File;

    function Is_Misc_Simple_Object (This_Object : in Object) return Boolean is
    begin
        return Any.Is_Simple_Object (This_Object) and then
                  not Any.Is_Ada_Unit (This_Object) and then
                  not Any.Is_File (This_Object);
    end Is_Misc_Simple_Object;

    function Is_Frozen (This_Object : in Object) return Boolean is
    begin
        return Directory_Tools.Any_Object.Is_Frozen (This_Object);
    end Is_Frozen;

    function Contains_Libraries
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Library, Transitive);
    end Contains_Libraries;

    function Contains_Directories
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Directory, Transitive);
    end Contains_Directories;

    function Contains_Worlds
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.World, Transitive);
    end Contains_Worlds;

    function Contains_Simple_Worlds
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Simple_World, Transitive);
    end Contains_Simple_Worlds;

    function Contains_Subsystems
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Subsystem, Transitive);
    end Contains_Subsystems;

    function Contains_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects (This_Object,  
                                           Utilities.View, Transitive);
    end Contains_Views;

    function Contains_Spec_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Spec_View, Transitive);
    end Contains_Spec_Views;

    function Contains_Load_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Load_View, Transitive);
    end Contains_Load_Views;

    function Contains_Working_Load_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Working_Load_View, Transitive);
    end Contains_Working_Load_Views;

    function Contains_Released_Load_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Released_Load_View, Transitive);
    end Contains_Released_Load_Views;

    function Contains_Code_Only_Load_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Code_Only_Load_View, Transitive);
    end Contains_Code_Only_Load_Views;

    function Contains_Combined_Views
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Combined_View, Transitive);
    end Contains_Combined_Views;

    function Contains_Simple_Objects
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Simple_Object, Transitive);
    end Contains_Simple_Objects;

    function Contains_Ada_Units
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Ada_Unit, Transitive);
    end Contains_Ada_Units;

    function Contains_Files
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.File, Transitive);
    end Contains_Files;

    function Contains_Misc_Simple_Objects
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Misc_Simple_Object, Transitive);
    end Contains_Misc_Simple_Objects;

    function Contains_Frozen_Objects
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Contains_Objects
                  (This_Object, Utilities.Frozen, Transitive);
    end Contains_Frozen_Objects;

    function Is_Contained
                (This_Object : in Object; By_Library : Object) return Boolean is

        Parent : Object := Directory_Tools.Traversal.Parent (This_Object);

    begin
        if Directory_Tools.Object.Equal (Parent, By_Library) then
            return True;
        elsif Any.Is_Root (Parent) then
            return False;
        else
            return Is_Contained (Parent, By_Library);
        end if;
    end Is_Contained;

    function Is_Contained_By_Directory
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Directory, Transitive);
    end Is_Contained_By_Directory;

    function Is_Contained_By_World
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed (This_Object, Utilities.World, Transitive);
    end Is_Contained_By_World;

    function Is_Contained_By_Simple_World
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Simple_World, Transitive);
    end Is_Contained_By_Simple_World;

    function Is_Contained_By_Subsystem
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Subsystem, Transitive);
    end Is_Contained_By_Subsystem;

    function Is_Contained_By_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed (This_Object, Utilities.View, Transitive);
    end Is_Contained_By_View;

    function Is_Contained_By_Spec_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Spec_View, Transitive);
    end Is_Contained_By_Spec_View;

    function Is_Contained_By_Load_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Load_View, Transitive);
    end Is_Contained_By_Load_View;

    function Is_Contained_By_Working_Load_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Working_Load_View, Transitive);
    end Is_Contained_By_Working_Load_View;

    function Is_Contained_By_Released_Load_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Released_Load_View, Transitive);
    end Is_Contained_By_Released_Load_View;

    function Is_Contained_By_Code_Only_Load_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Code_Only_Load_View, Transitive);
    end Is_Contained_By_Code_Only_Load_View;

    function Is_Contained_By_Combined_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Combined_View, Transitive);
    end Is_Contained_By_Combined_View;

    function Is_Contained_By_Units_Directory_Of_View
                (This_Object : in Object; Transitive : in Boolean := True)
                return Boolean is
    begin
        return Utilities.Is_Enclosed
                  (This_Object, Utilities.Units_Directory_Of_View, Transitive);
    end Is_Contained_By_Units_Directory_Of_View;

    function Directory_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Directory is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Directory, Transitive);
    end Directory_Containing;

    function World_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return World is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.World, Transitive);
    end World_Containing;

    function Simple_World_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Simple_World is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Simple_World, Transitive);
    end Simple_World_Containing;

    function Subsystem_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Subsystem is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Subsystem, Transitive);
    end Subsystem_Containing;

    function View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.View, Transitive);
    end View_Containing;

    function Spec_View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Spec_View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Spec_View, Transitive);
    end Spec_View_Containing;
    function Load_View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Load_View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Load_View, Transitive);
    end Load_View_Containing;

    function Working_Load_View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Working_Load_View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Working_Load_View, Transitive);
    end Working_Load_View_Containing;

    function Released_Load_View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Released_Load_View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Released_Load_View, Transitive);
    end Released_Load_View_Containing;

    function Code_Only_Load_View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Code_Only_Load_View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Code_Only_Load_View, Transitive);
    end Code_Only_Load_View_Containing;

    function Combined_View_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Combined_View is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Combined_View, Transitive);
    end Combined_View_Containing;

    function Units_Directory_Containing
                (This_Object : in Object; Transitive : in Boolean := True)
                return Units_Directory is
    begin
        return Utilities.Enclosing_For
                  (This_Object, Utilities.Units_Directory_Of_View, Transitive);
    end Units_Directory_Containing;

    function All_Objects_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Objects is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Anything, Transitive);
    end All_Objects_In;

    function Libraries_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Libraries is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Library, Transitive);
    end Libraries_In;

    function Directories_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Directories is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Directory, Transitive);
    end Directories_In;

    function Worlds_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Worlds is
    begin
        return Utilities.Objects_In (This_Object, Utilities.World, Transitive);
    end Worlds_In;

    function Simple_Worlds_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Simple_Worlds is
    begin  
        return Utilities.Objects_In
                  (This_Object, Utilities.Simple_World, Transitive);
    end Simple_Worlds_In;

    function Subsystems_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Subsystems is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Subsystem, Transitive);
    end Subsystems_In;

    function Views_In (This_Object : in Object; Transitive : in Boolean := True)
                      return Views is
    begin
        return Utilities.Objects_In (This_Object, Utilities.View, Transitive);
    end Views_In;

    function Spec_Views_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Spec_Views is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Spec_View, Transitive);
    end Spec_Views_In;

    function Load_Views_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Load_Views is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Load_View, Transitive);
    end Load_Views_In;

    function Working_Load_Views_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Working_Load_Views is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Working_Load_View, Transitive);
    end Working_Load_Views_In;

    function Released_Load_Views_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Released_Load_Views is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Released_Load_View, Transitive);
    end Released_Load_Views_In;

    function Code_Only_Load_Views_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Code_Only_Load_Views is
    begin  
        return Utilities.Objects_In
                  (This_Object, Utilities.Code_Only_Load_View, Transitive);
    end Code_Only_Load_Views_In;

    function Combined_Views_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Combined_Views is
    begin  
        return Utilities.Objects_In
                  (This_Object, Utilities.Combined_View, Transitive);
    end Combined_Views_In;

    function Simple_Objects_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Simple_Objects is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Simple_Object, Transitive);
    end Simple_Objects_In;

    function Ada_Units_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Ada_Units is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Ada_Unit, Transitive);
    end Ada_Units_In;

    function Files_In (This_Object : in Object; Transitive : in Boolean := True)
                      return Files is
    begin
        return Utilities.Objects_In (This_Object, Utilities.File, Transitive);
    end Files_In;

    function Misc_Simple_Objects_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Misc_Simple_Objects is
    begin
        return Utilities.Objects_In
                  (This_Object, Utilities.Misc_Simple_Object, Transitive);
    end Misc_Simple_Objects_In;

    function Frozen_Objects_In
                (This_Object : in Object; Transitive : in Boolean := True)
                return Frozen_Objects is
    begin
        return Utilities.Objects_In (This_Object, Utilities.Frozen, Transitive);
    end Frozen_Objects_In;

end Any;

    nblk1=1c
    nid=0
    hdr6=38
        [0x00] rec0=21 rec1=00 rec2=01 rec3=038
        [0x01] rec0=17 rec1=00 rec2=02 rec3=034
        [0x02] rec0=1c rec1=00 rec2=03 rec3=010
        [0x03] rec0=1b rec1=00 rec2=04 rec3=008
        [0x04] rec0=14 rec1=00 rec2=05 rec3=05a
        [0x05] rec0=1b rec1=00 rec2=06 rec3=026
        [0x06] rec0=1a rec1=00 rec2=07 rec3=014
        [0x07] rec0=17 rec1=00 rec2=08 rec3=06c
        [0x08] rec0=1b rec1=00 rec2=09 rec3=00a
        [0x09] rec0=1b rec1=00 rec2=0a rec3=04a
        [0x0a] rec0=1a rec1=00 rec2=0b rec3=012
        [0x0b] rec0=19 rec1=00 rec2=0c rec3=04c
        [0x0c] rec0=19 rec1=00 rec2=0d rec3=064
        [0x0d] rec0=1c rec1=00 rec2=0e rec3=008
        [0x0e] rec0=1b rec1=00 rec2=0f rec3=008
        [0x0f] rec0=1a rec1=00 rec2=10 rec3=03e
        [0x10] rec0=18 rec1=00 rec2=11 rec3=094
        [0x11] rec0=19 rec1=00 rec2=12 rec3=008
        [0x12] rec0=1a rec1=00 rec2=13 rec3=03e
        [0x13] rec0=1b rec1=00 rec2=14 rec3=000
        [0x14] rec0=19 rec1=00 rec2=15 rec3=038
        [0x15] rec0=19 rec1=00 rec2=16 rec3=00c
        [0x16] rec0=1b rec1=00 rec2=17 rec3=046
        [0x17] rec0=1b rec1=00 rec2=18 rec3=00a
        [0x18] rec0=1b rec1=00 rec2=19 rec3=014
        [0x19] rec0=18 rec1=00 rec2=1a rec3=088
        [0x1a] rec0=1b rec1=00 rec2=1b rec3=024
        [0x1b] rec0=06 rec1=00 rec2=1c rec3=000
    tail 0x215003e9c815c6540fa62 0x42a00088462061e03