|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 39936 (0x9c00)
Types: Ada Source
Notes: 03_class, FILE, R1k_Segment, e3_tag, generic, package body Object_Sets, seg_0045b3
└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
└─⟦cfc2e13cd⟧ »Space Info Vol 2«
└─⟦this⟧
with Object_Info;
package body Object_Sets is
function "+" (This_Set : in Set; That_Set : in Set) return Set
renames Union;
function Empty_Set return Set is
begin
return Directory_Tools.Object.Create;
end Empty_Set;
function Is_Empty (This_Set : in Set) return Boolean is
begin
return Object_Info.Any.Is_Empty (This_Set);
end Is_Empty;
function Number_In (This_Set : in Set) return Natural is
begin
return Object_Info.Any.Number_In (This_Set);
end Number_In;
function Are_Equal (This_Set : in Set; That_Set : in Set) return Boolean is
Working_Set : Set := This_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
if not Is_Member (That_Set,
Directory_Tools.Object.Value (Working_Set)) then
-- Found element in one set which isn't in other set.
Directory_Tools.Object.Reset (Working_Set);
return True;
end if;
Directory_Tools.Object.Next (Working_Set);
end loop;
Directory_Tools.Object.Reset (Working_Set);
return False;
exception
when others =>
Directory_Tools.Object.Reset (Working_Set);
return False;
end Are_Equal;
function Copy_Of (This_Set : in Set) return Set is
Working_Set : Set := This_Set;
Copy_Set : Set := Empty_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
Add (Directory_Tools.Object.Value (Working_Set), Copy_Set);
Directory_Tools.Object.Next (Working_Set);
end loop;
Directory_Tools.Object.Reset (Working_Set);
return Copy_Set;
end Copy_Of;
function Is_Member
(This_Set : in Set; This_Element : in Element) return Boolean is
begin
return Directory_Tools.Object.Has (This_Set, This_Element);
end Is_Member;
procedure Add (This_Element : in Element; This_Set : in out Set) is
Dummy : Boolean;
begin
if Object_Info.Any.Is_Good (This_Element) and then
not Is_Member (This_Set, This_Element) then
if Directory_Tools.Object.Is_Nil (This_Set) then
This_Set := Directory_Tools.Object.Create;
end if;
Directory_Tools.Object.Add (This_Set, This_Element, Dummy);
end if;
end Add;
procedure Remove (This_Element : in Element; This_Set : in out Set) is
Dummy : Boolean;
begin
Directory_Tools.Object.Remove (This_Set, This_Element, Dummy);
end Remove;
procedure Sort (This_Set : in out Set) is
type Sorted_Array is array (1 .. Number_In (This_Set)) of Boolean;
Already_Sorted : Sorted_Array := (others => False);
Remaining : Natural := Number_In (This_Set);
Sorted_Set : Set := Empty_Set;
Smallest_This_Pass : Element;
Index_Of_Smallest : Natural;
Current_Index : Natural;
begin
while Remaining > 0 loop
Current_Index := 1;
Directory_Tools.Object.Reset (This_Set);
Smallest_This_Pass := Directory_Tools.Object.Value (This_Set);
while not Directory_Tools.Object.Done (This_Set) loop
if not Already_Sorted (Current_Index) then
-- Current element hasn't already been put in
-- the sorted array, so test it.
if Directory_Tools.Object.Value (This_Set) <
Smallest_This_Pass then
-- Current element is smaller than the smallest
-- element found so far on this pass, so make
-- it the new smallest.
Smallest_This_Pass :=
Directory_Tools.Object.Value (This_Set);
Index_Of_Smallest := Current_Index;
end if;
end if;
Directory_Tools.Object.Next (This_Set);
Current_Index := Current_Index + 1;
end loop;
Add (Smallest_This_Pass, Sorted_Set);
Already_Sorted (Index_Of_Smallest) := True;
Remaining := Remaining - 1;
end loop;
This_Set := Sorted_Set;
end Sort;
procedure Filter (This_Set : in out Set) is
New_Set : Set := Empty_Set;
begin
Directory_Tools.Object.Reset (This_Set);
while not Directory_Tools.Object.Done (This_Set) loop
if not Dont_Want (Directory_Tools.Object.Value (This_Set)) then
-- Want current element, so add it.
Add Directory_Tools.Object.Value (This_Set), New_Set);
end if;
Directory_Tools.Object.Next (This_Set);
end loop;
This_Set := New_Set;
end Filter;
procedure Process_Elements (This_Set : in out Set) is
begin
Directory_Tools.Object.Reset (This_Set);
while not Directory_Tools.Object.Done (This_Set) loop
declare
Current_Element : Element :=
Directory_Tools.Object.Value (This_Set);
begin
Process (Current_Element);
end;
Directory_Tools.Object.Next (This_Set);
end loop;
end Process_Elements;
procedure Process_Elements_With_State
(This_Set : in out Set; This_State : in out Process_State) is
begin
Initialize (This_State);
Directory_Tools.Object.Reset (This_Set);
while not Directory_Tools.Object.Done (This_Set) loop
declare
Current_Element : Element :=
Directory_Tools.Object.Value (This_Set);
begin
Process (Current_Element, This_State);
end;
Directory_Tools.Object.Next (This_Set);
end loop;
Finalize (This_State);
end Process_Elements_With_State;
function Union (This_Set : in Set; That_Set : in Set) return Set is
Union_Set : Set := Empty_Set;
procedure Union_Copy (This_Set : in Set; New_Set : in out Set) is
Working_Set : Set := This_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
Add (Directory_Tools.Object.Value (Working_Set), New_Set);
Directory_Tools.Object.Next (Working_Set);
end loop;
end Union_Copy;
begin
Union_Copy (This_Set, Union_Set);
Union_Copy (That_Set, Union_Set);
return Union_Set;
end Union;
function Intersection (This_Set : in Set; That_Set : in Set) return Set is
Working_Set : Set := This_Set;
Intersection_Set : Set := Empty_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
if Is_Member (That_Set,
Directory_Tools.Object.Value (Working_Set)) then
-- Found an element in the one set which is also in the
-- other set, so add it to the intersection set.
Add (Directory_Tools.Object.Value (Working_Set),
Intersection_Set);
end if;
Directory_Tools.Object.Next (Working_Set);
end loop;
return Intersection_Set;
end Intersection;
function Exclusive_Or (This_Set : in Set; That_Set : in Set) return Set is
Xor_Set : Set := Empty_Set;
procedure Xor_Copy (This_Set : in Set;
Except_For : in Set;
Into : in out Set) is
Working_Set : Set := This_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
if not Is_Member (Except_For, Directory_Tools.Object.Value
(Working_Set)) then
-- Found an element in the one set which is not also
-- in the other set, so add it to the new set.
Add (Directory_Tools.Object.Value (Working_Set), Into);
end if;
Directory_Tools.Object.Next (Working_Set);
end loop;
end Xor_Copy;
begin
Xor_Copy (This_Set, That_Set, Xor_Set);
Xor_Copy (That_Set, This_Set, Xor_Set);
return Xor_Set;
end Exclusive_Or;
function Subtraction (This_Set : in Set; Except_For : in Set) return Set is
Working_Set : Set := This_Set;
Subtraction_Set : Set := Empty_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
if not Is_Member (Except_For,
Directory_Tools.Object.Value (Working_Set)) then
-- Found an element in the one set which is not also
-- in the other set, so add it to the subtraction set.
Add (Directory_Tools.Object.Value (Working_Set),
Subtraction_Set);
end if;
Directory_Tools.Object.Next (Working_Set);
end loop;
return Subtraction_Set;
end Subtraction;
function Subset (This_Set : in Set; Contains : in Set) return Boolean is
Working_Set : Set := Contains;
Result : Boolean := True;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
if not Is_Member (This_Set,
Directory_Tools.Object.Value (Working_Set)) then
-- Found an element in "Contains" which is not in the
-- other set, so is not a subset of the other set.
Result := False;
exit;
end if;
Directory_Tools.Object.Next (Working_Set);
end loop;
return Result;
end Subset;
function Proper_Subset
(This_Set : in Set; Contains : in Set) return Boolean is
begin
return Subset (This_Set, Contains) and then
(Number_In (This_Set) > Number_In (Contains));
end Proper_Subset;
procedure Screen (These_Units : in out Set;
Exclude : in Set;
Specs_Only : in Boolean;
Include_Universe_Mirrors : in Boolean) is
Screened : Set := Empty_Set;
Current : Element;
begin
Directory_Tools.Object.Reset (These_Units);
while not Directory_Tools.Object.Done (These_Units) loop
Current := Directory_Tools.Object.Value (These_Units);
if Object_Info.Any.Is_Bad (Current) then
-- Current unit is bad, so don't add it.
null;
elsif Is_Member (Exclude, Current) then
-- Already have the current unit, so don't add it.
null;
elsif Specs_Only and then not Object_Info.Ada.Is_Spec (Current) then
-- Client wants specs only, and current unit is not a spec,
-- so don't add it.
null;
elsif not Include_Universe_Mirrors and then
Object_Info.Ada.Is_Universe_Mirror (Current) then
-- Client doesn't want universe mirrors, and current unit is
-- a universe mirror, so don't add it.
null;
else
-- Current unit met all criteria, so add it.
Add (Current, Screened);
end if;
Directory_Tools.Object.Next (These_Units);
end loop;
These_Units := Screened;
end Screen;
generic
with function Immediate_Dependencies
(This_Element : in Element;
Code_Share_Generics : in Boolean;
This_Activity : in Activity.Activity_Name) return Set;
function Single_Unit_Dependency_Closure
(Unit : in Element;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set;
function Single_Unit_Dependency_Closure
(Unit : in Element;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
Closure : Set := Empty_Set;
New_Units : Set := Empty_Set;
procedure Get_Next_Units (These_Units : in out Set) is
New_Units : Set := Empty_Set;
begin
Directory_Tools.Object.Reset (These_Units);
while not Directory_Tools.Object.Done (These_Units) loop
New_Units := New_Units +
Immediate_Dependencies
(Directory_Tools.Object.Value (These_Units),
Code_Share_Generics, This_Activity);
Directory_Tools.Object.Next (These_Units);
end loop;
These_Units := New_Units;
end Get_Next_Units;
begin
New_Units := Immediate_Dependencies
(Unit, Code_Share_Generics, This_Activity);
loop
Screen (New_Units, Closure, Specs_Only, Include_Universe_Mirrors);
Closure := Closure + New_Units;
if not Transitive then
-- Only needed to calculate first level.
exit;
elsif Is_Empty (New_Units) then
-- There were no new units, so closure is complete.
exit;
else
-- There are more units requiring processing.
Get_Next_Units (New_Units);
end if;
end loop;
return Closure;
end Single_Unit_Dependency_Closure;
generic
with function Single_Unit_Dependency_Closure_Instantiation
(Unit : in Element;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set;
function Multiple_Unit_Dependency_Closure
(Units : in Set;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set;
function Multiple_Unit_Dependency_Closure
(Units : in Set;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
Working_Set : Set := Units;
Closure : Set := Empty_Set;
begin
Directory_Tools.Object.Reset (Working_Set);
while not Directory_Tools.Object.Done (Working_Set) loop
Closure := Closure + Single_Unit_Dependency_Closure_Instantiation
(Directory_Tools.Object.Value (Working_Set),
Specs_Only, Transitive,
Include_Universe_Mirrors,
Code_Share_Generics, This_Activity);
Directory_Tools.Object.Next (Working_Set);
end loop;
return Closure;
end Multiple_Unit_Dependency_Closure;
function Spec_Is_Generic_For (This_Element : in Element) return Boolean is
-- Returns True if the spec associated with the specified element
-- is a generic spec.
begin
return Object_Info.Ada.Is_Generic_Spec
(Object_Info.Ada.Spec_For (This_Element));
end Spec_Is_Generic_For;
function Immediate_Dependencies_On
(This_Element : in Element;
Code_Share_Generics : in Boolean;
This_Activity : in Activity.Activity_Name) return Set is
Dependencies : Set := Object_Info.Ada.Dependents_Of (This_Element);
begin
if Object_Info.Any.Is_Ada_Unit (This_Element) then
-- Deal with question of code sharing.
if not Code_Share_Generics and then
Object_Info.Ada.Is_Body_Or_Subunit (This_Element) and then
Spec_Is_Generic_For (This_Element) then
-- Current element is body or subunit associated with
-- a generic spec, and generic bodies are not code-shared.
-- Therefore, the current element will be macro-
-- inline expanded, and dependencies on the current
-- element include dependencies on its spec.
Dependencies := Dependencies +
Object_Info.Ada.Dependents_Of
(Object_Info.Ada.Spec_For (This_Element));
end if;
-- Perform spec look-through.
if Object_Info.Ada.Is_Spec_In_Load_View (This_Element) then
-- The element is a spec in a load view, so it has an associated spec
-- in a spec view. Anything that depends on the spec in the spec view
-- in actuality depends on the current element, so add the spec view
-- spec to the dependencies (so that the next pass will get the
-- dependencies on it).
Add (Object_Info.Ada.Spec_In_Other_View
(This_Element, This_Activity), Dependencies);
end if;
end if;
return Dependencies;
end Immediate_Dependencies_On;
function Dependencies_On_Single_Unit is
new Single_Unit_Dependency_Closure (Immediate_Dependencies_On);
function Dependencies_On
(Unit : in Element;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
begin
return Dependencies_On_Single_Unit
(Unit, Specs_Only, Transitive, Include_Universe_Mirrors,
Code_Share_Generics, This_Activity);
end Dependencies_On;
function Dependencies_On_Multiple_Units is
new Multiple_Unit_Dependency_Closure (Dependencies_On);
function Dependencies_On
(Units : in Set;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
begin
return Dependencies_On_Multiple_Units
(Units, Specs_Only, Transitive, Include_Universe_Mirrors,
Code_Share_Generics, This_Activity);
end Dependencies_On;
function Immediate_Dependencies_By
(This_Element : in Element;
Code_Share_Generics : in Boolean;
This_Activity : in Activity.Activity_Name) return Set is
Dependencies : Set := Object_Info.Ada.Specs_Withed_By (This_Element);
Families_Of_Generic_Specs : Set := Empty_Set;
Specs_In_Load_Views : Set := Empty_Set;
begin
if Object_Info.Any.Is_Ada_Unit (This_Element) then
-- Deal with bodies and subunits.
if Object_Info.Ada.Is_Subunit (This_Element) then
Add (Object_Info.Ada.Parent_Of (This_Element), Dependencies);
elsif Object_Info.Ada.Is_Body (This_Element) then
Add (Object_Info.Ada.Spec_For (This_Element), Dependencies);
end if;
-- Deal with question of code sharing.
if not Code_Share_Generics then
Directory_Tools.Object.Reset (Dependencies); while not Directory_Tools.Object.Done (Dependencies) loop
if Object_Info.Ada.Is_Generic_Spec
(Directory_Tools.Object.Value (Dependencies)) then
-- The element depends on a generic spec. Since the body and
-- subunits of the generic spec are not code-shared, they
-- will be macro-inline expanded. Therefore, the element
-- depends on the entire family of the generic spec.
Families_Of_Generic_Specs :=
Families_Of_Generic_Specs +
Family (Directory_Tools.Object.Value
(Dependencies));
end if;
Directory_Tools.Object.Next (Dependencies);
end loop;
end if;
Dependencies := Dependencies + Families_Of_Generic_Specs;
-- Perform spec look-through.
Directory_Tools.Object.Reset (Dependencies);
while not Directory_Tools.Object.Done (Dependencies) loop
if Object_Info.Ada.Is_Spec_In_Spec_View
(Directory_Tools.Object.Value (Dependencies)) then
-- The element depends on a spec in a spec view. So add
-- the associated spec in the load view to the dependencies.
Add (Object_Info.Ada.Spec_In_Other_View
(Directory_Tools.Object.Value (Dependencies),
This_Activity), Specs_In_Load_Views);
end if;
Directory_Tools.Object.Next (Dependencies);
end loop;
Dependencies := Dependencies + Specs_In_Load_Views;
end if;
return Dependencies;
end Immediate_Dependencies_By;
function Dependencies_By_Single_Unit is
new Single_Unit_Dependency_Closure (Immediate_Dependencies_By);
function Dependencies_By (Unit : in Element;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
begin
return Dependencies_By_Single_Unit
(Unit, Specs_Only, Transitive, Include_Universe_Mirrors,
Code_Share_Generics, This_Activity);
end Dependencies_By;
function Dependencies_By_Multiple_Units is
new Multiple_Unit_Dependency_Closure (Dependencies_By);
function Dependencies_By (Units : in Set;
Specs_Only : in Boolean := False;
Transitive : in Boolean := True;
Include_Universe_Mirrors : in Boolean := False;
Code_Share_Generics : in Boolean := True;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
begin
return Dependencies_By_Multiple_Units
(Units, Specs_Only, Transitive, Include_Universe_Mirrors,
Code_Share_Generics, This_Activity);
end Dependencies_By;
function Immediate_Family_Dependencies_On
(This_Element : in Element;
Code_Share_Generics : in Boolean;
This_Activity : in Activity.Activity_Name) return Set is
Dependencies : Set := Object_Info.Ada.Subunits_Of (This_Element);
begin
if Object_Info.Ada.Is_Spec (This_Element) then
-- Add body.
Add (Object_Info.Ada.Body_For (This_Element), Dependencies);
-- Add subunits.
Dependencies := Dependencies +
Object_Info.Ada.Subunits_Of
(Object_Info.Ada.Body_For (This_Element));
-- Perform spec look-through.
if Object_Info.Ada.Is_Spec_In_Spec_View (This_Element) then
Add (Object_Info.Ada.Spec_In_Other_View
(This_Element, This_Activity), Dependencies);
end if;
elsif Object_Info.Ada.Is_Body_Or_Subunit (This_Element) then
-- Add subunits.
Dependencies := Dependencies +
Object_Info.Ada.Subunits_Of (This_Element);
end if;
return Dependencies;
end Immediate_Family_Dependencies_On;
function Family_Dependencies_On is
new Single_Unit_Dependency_Closure (Immediate_Family_Dependencies_On);
function Family (Unit : in Element;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
Family_Dependencies : Set :=
Family_Dependencies_On (Unit,
Specs_Only => False,
Transitive => True,
Include_Universe_Mirrors => True,
Code_Share_Generics => True,
This_Activity => This_Activity);
begin
if Object_Info.Any.Is_Ada_Unit (Unit) then
Add (Unit, Family_Dependencies);
end if;
return Family_Dependencies;
end Family;
function Immediate_Execution_Closure_For
(This_Element : in Element;
Code_Share_Generics : in Boolean;
This_Activity : in Activity.Activity_Name) return Set is
Dependencies : Set := Object_Info.Ada.Specs_Withed_By (This_Element);
Families_Of_Elements : Set := Empty_Set;
Specs_In_Load_Views : Set := Empty_Set;
begin
if Object_Info.Any.Is_Ada_Unit (This_Element) then
-- Add the element itself to the closure.
Add (This_Element, Dependencies);
-- Deal with bodies and subunits.
if Object_Info.Ada.Is_Subunit (This_Element) then
Add (Object_Info.Ada.Parent_Of (This_Element), Dependencies);
elsif Object_Info.Ada.Is_Body (This_Element) then
Add (Object_Info.Ada.Spec_For (This_Element), Dependencies);
end if;
-- Add families of all elements to dependencies.
Directory_Tools.Object.Reset (Dependencies);
while not Directory_Tools.Object.Done (Dependencies) loop
Families_Of_Elements :=
Families_Of_Elements +
Family (Directory_Tools.Object.Value (Dependencies));
Directory_Tools.Object.Next (Dependencies);
end loop;
Dependencies := Dependencies + Families_Of_Elements;
-- Perform spec look-through.
Directory_Tools.Object.Reset (Dependencies);
while not Directory_Tools.Object.Done (Dependencies) loop
if Object_Info.Ada.Is_Spec_In_Spec_View
(Directory_Tools.Object.Value (Dependencies)) then
-- The element depends on a spec in a spec view. So add
-- the associated spec in the load view to the dependencies.
Add (Object_Info.Ada.Spec_In_Other_View
(Directory_Tools.Object.Value (Dependencies),
This_Activity), Specs_In_Load_Views);
end if;
Directory_Tools.Object.Next (Dependencies);
end loop;
Dependencies := Dependencies + Specs_In_Load_Views;
end if;
return Dependencies;
end Immediate_Execution_Closure_For;
function Execution_Closure_For_Single_Unit is
new Single_Unit_Dependency_Closure (Immediate_Execution_Closure_For);
function Execution_Closure_For
(Unit : in Element;
Include_Universe_Mirrors : in Boolean := False;
This_Activity : in Activity.Activity_Name :=
Activity.The_Current_Activity) return Set is
begin
return Execution_Closure_For_Single_Unit
(Unit,
Specs_Only => False,
Transitive => True,
Include_Universe_Mirrors => Include_Universe_Mirrors,
Code_Share_Generics => True,
This_Activity => This_Activity);
end Execution_Closure_For;
end Object_Sets;
nblk1=26
nid=0
hdr6=4c
[0x00] rec0=20 rec1=00 rec2=01 rec3=062
[0x01] rec0=20 rec1=00 rec2=02 rec3=00a
[0x02] rec0=00 rec1=00 rec2=26 rec3=006
[0x03] rec0=1d rec1=00 rec2=03 rec3=094
[0x04] rec0=15 rec1=00 rec2=04 rec3=04a
[0x05] rec0=01 rec1=00 rec2=25 rec3=00c
[0x06] rec0=19 rec1=00 rec2=05 rec3=028
[0x07] rec0=00 rec1=00 rec2=24 rec3=002
[0x08] rec0=1b rec1=00 rec2=06 rec3=026
[0x09] rec0=1d rec1=00 rec2=07 rec3=02c
[0x0a] rec0=1a rec1=00 rec2=08 rec3=030
[0x0b] rec0=00 rec1=00 rec2=23 rec3=00a
[0x0c] rec0=18 rec1=00 rec2=09 rec3=02a
[0x0d] rec0=1a rec1=00 rec2=0a rec3=014
[0x0e] rec0=00 rec1=00 rec2=22 rec3=01a
[0x0f] rec0=1a rec1=00 rec2=0b rec3=048
[0x10] rec0=17 rec1=00 rec2=0c rec3=02a
[0x11] rec0=19 rec1=00 rec2=0d rec3=018
[0x12] rec0=18 rec1=00 rec2=0e rec3=006
[0x13] rec0=00 rec1=00 rec2=21 rec3=004
[0x14] rec0=17 rec1=00 rec2=0f rec3=022
[0x15] rec0=16 rec1=00 rec2=10 rec3=01c
[0x16] rec0=15 rec1=00 rec2=11 rec3=00c
[0x17] rec0=00 rec1=00 rec2=20 rec3=008
[0x18] rec0=1a rec1=00 rec2=12 rec3=00e
[0x19] rec0=0f rec1=00 rec2=13 rec3=082
[0x1a] rec0=15 rec1=00 rec2=14 rec3=064
[0x1b] rec0=18 rec1=00 rec2=15 rec3=006
[0x1c] rec0=16 rec1=00 rec2=16 rec3=002
[0x1d] rec0=10 rec1=00 rec2=17 rec3=01c
[0x1e] rec0=13 rec1=00 rec2=18 rec3=050
[0x1f] rec0=14 rec1=00 rec2=19 rec3=046
[0x20] rec0=15 rec1=00 rec2=1a rec3=044
[0x21] rec0=15 rec1=00 rec2=1b rec3=05c
[0x22] rec0=15 rec1=00 rec2=1c rec3=09e
[0x23] rec0=17 rec1=00 rec2=1d rec3=014
[0x24] rec0=11 rec1=00 rec2=1e rec3=00c
[0x25] rec0=18 rec1=00 rec2=1f rec3=001
tail 0x217002150815c65541a1c 0x42a00088462061e03