max_stars_repo_path stringlengths 4 261 | max_stars_repo_name stringlengths 6 106 | max_stars_count int64 0 38.8k | id stringlengths 1 6 | text stringlengths 7 1.05M |
|---|---|---|---|---|
alloy4fun_models/trainstlt/models/11/zz3PrsJZM2JR275tt.als | Kaixi26/org.alloytools.alloy | 0 | 3815 | open main
pred idzz3PrsJZM2JR275tt_prop12 {
}
pred __repair { idzz3PrsJZM2JR275tt_prop12 }
check __repair { idzz3PrsJZM2JR275tt_prop12 <=> prop12o } |
oeis/011/A011676.asm | neoneye/loda-programs | 11 | 14695 | <gh_stars>10-100
; A011676: A binary m-sequence: expansion of reciprocal of x^7+x^6+x^4+x^2+1.
; Submitted by <NAME>(s4)
; 0,0,0,0,0,0,1,0,1,0,0,0,0,1,1,0,1,1,0,0,1,0,0,0,0,0,1,1,1,1,0,0,0,1,0,1,1,0,1,0,1,1,0,0,0,0,1,0,0,0,1,0,0,1,1,1,0,1,1,1,1,0,1,0,0,0,1,1,0,0,1,1,0,1,0,0,1,1,0,0,0,1,1,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,1,0
lpb $0
sub $0,1
mod $1,2
add $2,5
mov $3,$0
bin $3,$2
add $1,$3
add $2,1
lpe
mov $0,$1
|
include/coollib.asm | L2jLiga/assembler | 0 | 167987 | ; This is cool working library for Output and Input w/o Far
; If u want to output AnyThing move at in AX
getch
return
;
; Output functions:
;
; Go to newline
NewLine macro ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
push dx ; Store registers..
push ax ;
mov ah,2 ; Function "console output"
mov dl,13 ; To line-start
int 21h ; do it!
mov dl,10 ; One step down
int 21h ; do it!
pop ax ; Restore registers..
pop dx ;
prochl endm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Output string
; In DX - offset of MSG, Message end - 24h
OutStr macro ;;;;;;;;;;;;;;;;;;;;;;
push ax ; Store registers..
mov ah, 09h ; print function is 9.
int 21h ; do it!
pop ax ; Restore registers..
OutStr endm ;;;;;;;;;;;;;;;;;;;;;;
; Output: int
; Input: Int in AX (00-99)
OutInt proc ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
push ax ; Store registers..
push dx ;
cmp AH,0FFh ;
jNE OutInt_cont ;
;
OutInt_cont: ; TO DO:
aam ; If ZF inst - print "-"
add ax,3030h ;
mov dl,ah ;
mov dh,al ;
mov ah,02 ;
int 21h ;
mov dl,dh ;
int 21h ;
pop dx ;
pop ax ;
ret ;
OutInt endp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
OutInt3 proc
push ax
push bx
push dx
mov bl,100
div bl ; AL - 100, AH 0,xx
pop bx
mov dh,ah ; DH 0,xx
mov dl,al ; DL 1xx
add dl,30h
mov ah,02
int 21h
mov ah,0
mov al,dh
pop dx
call outint ; Out 0,xx part of int
pop ax
ret
OutInt3 endp
;
; Cursor left
;
CurLeft macro ;;;;;;;;;;;;;;;;;;;
push dx ; Store registers
push ax ;
mov ah,2 ; backspace
mov dl,08h ;
int 21h ;
mov ax,0e00h ; draw empty symbol
int 10h ;
mov ah,2 ; backspace again
mov dl,08h ;
int 21h ;
pop ax ; Restore registers
pop dx ;;;;;;;;;;;;;;;;;;;
CurLeft endm
;
; Input functions
;
InIntkb_getInput macro ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
jmp InIntkb_InpStart ; Start input
;
InIntkb_InpBackspace: ; If backspace pressed
cmp FirstFlag,0 ;
;
jE InIntkb_InpStart ;
;
CurLeft ;
cmp CL,cnt ;
;
jE InIntkb_InpStart_again ;
;
INC CX ;
DEC SI ;
cmp CL,cnt ;
;
jE check_SignFlag ;
jmp InIntkb_InpStart ;
;
check_SignFlag: ; Check for sign flag
cmp SignFlag,1 ;
;
jE InIntkb_InpStart ;
;
InIntkb_InpStart_again: ; If we have sign
mov SignFlag,0 ;
mov FirstFlag,0 ;
;
jmp InIntkb_InpStart ;
;
InIntkb_InpEnter: ; if Enter pressed
mov AL,0FFh ;
;
jmp InIntkb_finish ;
;
InIntkb_InpStart: ; Input start,
mov ax,0 ; Reset AX
int 16h ; An read symbol from KB
mov ah,"-" ; If "-" pressed, code: 2Dh
cmp al,ah ;
;
jNE InIntkb_cont ;
;
cmp FirstFlag,1 ; If not 1st symbol - not read
;
jE InIntkb_InpStart ;
;
mov SignFlag,1 ;
inc CL ;
;
jmp InIntkb_out ;
;
InIntkb_cont: ;
cmp AL,0Dh ; If Enter pressed, code: 0Dh
;
jE InIntkb_InpEnter ;
;
cmp AL,08h ; If Backspace pressed, code: 08h
;
jE InIntkb_InpBackspace ;
;
cmp AL,39h ; Check If no int pressed, code: 30-39h
;
jA InIntkb_InpStart ;
;
cmp AL,30h ;
;
jB InIntkb_InpStart ;
;
InIntkb_out: ;
mov FirstFlag,1 ; Setup flag "One Key Already pressed"
mov ah,0eh ; Output enterred number
int 10h ;
sub al,30h ; Convert Number from ASCII code to INT
;
InIntkb_finish: ; Finish HIM!
InIntkb_getInput endm ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
InIntkb_enter_getInput macro
; Start input
jmp InIntkb_enter_InpStart
; If backspace pressed
InIntkb_enter_InpBackspace:
CurLeft
INC CL
DEC SI
jmp InInt_input
;if Enter pressed
InIntkb_enter_InpEnter:
mov AL,0FFh
;DEC SI
jmp InIntkb_enter_finish
InIntkb_enter_InpStart:
mov ax,0
int 16h
InIntkb_enter_cont:
cmp AL,0Dh ; If Enter pressed
jE InIntkb_enter_InpEnter
cmp AL,08h ; If Backspace pressed
jE InIntkb_enter_InpBackspace
jmp InIntkb_enter_InpStart
InIntkb_enter_finish:
InIntkb_enter_getInput endm
InIntkb_getStep proc
cmp CL,5
jNE less4
mov bx,10000
jmp getStep_cont
less4:
cmp CL,4
jNE less3
mov bx,1000
jmp getStep_cont
less3:
cmp CL,3
jNE less2
mov bx,100
jmp getStep_cont
less2:
cmp CL,2
jNE less1
mov bx,10
jmp getStep_cont
less1:
mov bx,1
getStep_cont:
mov ah,0
mul bx
add stepper,ax
ret
InIntkb_getStep endp
InIntkb_convert proc ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
mov CX,SI ; Copy length of number to CX
mov SI,0 ; Reset counter
;
InIntkb_convert_cycle: ; Cycle
mov AL,integer[SI] ; Copy to AL part of number
call InIntkb_getStep ; Convert part of BCD-number to Normal and store it..
inc SI ; Counter++
loop InIntkb_convert_cycle ; Next..:)
;
mov ax,stepper ; Copy our normal number to AX
;
cmp SignFlag,1 ; Checking for "-"
jNE InIntkb_convert_ret ; If haven't - return int
neg AX ; Else negative number
mov stepper,AX ;
;
InIntkb_convert_ret: ; If allfine..
ret ; And return...
InIntkb_convert endp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Input integer
; USE: input - AL=SignFlag: 1 - Signed INT, 0 - UnSigned INT
; Output - number in AX (range -32768 - 32767)
InInt proc ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
cmp AL,5 ; Check input parametr
;
jB InInt_Check_no2 ;
;
mov AX,5 ;
InInt_Check_no2: ;
cmp AL,1 ;
;
jA InInt_pusher ;
;
mov AL,2 ;
;
InInt_pusher: ;
push SI ; store registers...
push CX ;
push BX ;
push DI ;
mov DI,DS ;
mov BL,AL ; Copy CNT to BL (temporary)
;
mov AX,TempData ; Initializate Temporary Data Segment
mov DS,AX ;
mov FirstFlag,0 ;
;
mov cnt,BL ;
mov stepper,0 ; Clear last number
mov SI,0 ; Clear Counter
mov CH,0 ;
mov CL,cnt ; Max length of number
;
InInt_input: ;
InIntkb_getInput ; Read int from KB
cmp AL,0FFh ; If enter pressed
jE InInt_finisher ; Then ending input
cmp AL,0FDh ; If enter "-"
jE input_sign ; Skip counter++
mov integer[SI],AL ; Move our int to VAR
inc SI ; Increment Counter
;
input_sign: ;
;
loop InInt_input ; Go to Input
;
InIntkb_enter_getInput ; Check for Input ending (allow to use Backspace or Enter)
;
InInt_finisher: ; Marker for input ending
call InIntkb_convert; ; Convert our number from BCD to normal
;
InInt_return: ; Function endings...
mov DS,DI ; Restore Data Segment
pop DI ; Return registers values from store...
pop BX ;
pop CX ;
pop SI ;
;
newline ; Print newline
ret ; And return to caller
InInt endp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; System functions
;
; Wait for Input
getch macro ;;;;;;;;;;;;;;;;;;;;;;;;;;;
push ax ; AX to store..
mov ah,0 ; Call Interrupt with AH=0
int 16h ; "Waiting for input..."
pop ax ; restore AX from store..
endm ;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Exit
return macro
mov ax,4Ch
int 21h
return endm
Cseg ends
end start |
programs/oeis/162/A162962.asm | karttu/loda | 1 | 10300 | ; A162962: a(n) = 5*a(n-2) for n > 2; a(1) = 1, a(2) = 5.
; 1,5,5,25,25,125,125,625,625,3125,3125,15625,15625,78125,78125,390625,390625,1953125,1953125,9765625,9765625,48828125,48828125,244140625,244140625,1220703125,1220703125,6103515625,6103515625,30517578125
add $0,1
div $0,2
mov $1,5
pow $1,$0
|
oeis/028/A028059.asm | neoneye/loda-programs | 11 | 163018 | <reponame>neoneye/loda-programs<filename>oeis/028/A028059.asm
; A028059: Expansion of 1/((1-3x)(1-5x)(1-7x)(1-8x)).
; Submitted by <NAME>
; 1,23,338,4054,43323,430269,4065916,37085708,329561045,2871469315,24640946694,208933723362,1754722389967,14623596707561,121104748389872,997726082646616,8184406735022889,66895347552055407
mov $1,1
mov $2,$0
mov $3,$0
lpb $2
mov $0,$3
sub $2,1
sub $0,$2
seq $0,17521 ; Expansion of 1/((1-3*x)*(1-5*x)*(1-8*x)).
sub $0,$1
mul $1,8
add $1,$0
lpe
mov $0,$1
|
src/ui/bases-ui.adb | thindil/steamsky | 80 | 22213 | <gh_stars>10-100
-- Copyright (c) 2020-2021 <NAME> <<EMAIL>>
--
-- This program is free software: you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program. If not, see <http://www.gnu.org/licenses/>.
with Ada.Characters.Handling; use Ada.Characters.Handling;
with Ada.Containers.Generic_Array_Sort;
with Interfaces.C; use Interfaces.C;
with Interfaces.C.Strings; use Interfaces.C.Strings;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
with GNAT.Directory_Operations; use GNAT.Directory_Operations;
with CArgv; use CArgv;
with Tcl; use Tcl;
with Tcl.Ada; use Tcl.Ada;
with Tcl.Tk.Ada; use Tcl.Tk.Ada;
with Tcl.Tk.Ada.Grid;
with Tcl.Tk.Ada.Widgets; use Tcl.Tk.Ada.Widgets;
with Tcl.Tk.Ada.Widgets.Canvas; use Tcl.Tk.Ada.Widgets.Canvas;
with Tcl.Tk.Ada.Widgets.Menu; use Tcl.Tk.Ada.Widgets.Menu;
with Tcl.Tk.Ada.Widgets.Toplevel.MainWindow;
use Tcl.Tk.Ada.Widgets.Toplevel.MainWindow;
with Tcl.Tk.Ada.Widgets.TtkEntry; use Tcl.Tk.Ada.Widgets.TtkEntry;
with Tcl.Tk.Ada.Widgets.TtkFrame; use Tcl.Tk.Ada.Widgets.TtkFrame;
with Tcl.Tk.Ada.Widgets.TtkLabel; use Tcl.Tk.Ada.Widgets.TtkLabel;
with Tcl.Tk.Ada.Widgets.TtkPanedWindow; use Tcl.Tk.Ada.Widgets.TtkPanedWindow;
with Tcl.Tk.Ada.Widgets.TtkScrollbar; use Tcl.Tk.Ada.Widgets.TtkScrollbar;
with Tcl.Tk.Ada.Winfo; use Tcl.Tk.Ada.Winfo;
with Bases.Ship; use Bases.Ship;
with Bases.Trade; use Bases.Trade;
with BasesTypes; use BasesTypes;
with Config; use Config;
with CoreUI; use CoreUI;
with Crafts; use Crafts;
with Maps; use Maps;
with Maps.UI; use Maps.UI;
with Ships.Crew; use Ships.Crew;
with Table; use Table;
with Utils.UI; use Utils.UI;
package body Bases.UI is
-- ****iv* BUI/BUI.BaseTable
-- FUNCTION
-- Table with info about available base actions
-- SOURCE
BaseTable: Table_Widget (3);
-- ****
-- ****iv* BUI/BUI.Items_Indexes
-- FUNCTION
-- Indexes of the crafting recipes/wounded crew members/damaged ship modules
-- HISTORY
-- 6.5 - Added
-- SOURCE
Items_Indexes: UnboundedString_Container.Vector;
-- ****
-- ****o* BUI/BUI.Show_Base_UI_Command
-- FUNCTION
-- Show the selected base action
-- PARAMETERS
-- ClientData - Custom data send to the command. Unused
-- Interp - Tcl interpreter in which command was executed.
-- Argc - Number of arguments passed to the command.
-- Argv - Values of arguments passed to the command.
-- RESULT
-- This function always return TCL_OK
-- COMMANDS
-- ShowBaseUI UIType search page
-- UIType can be heal, repair, recipes. Search is a string which will be
-- looked for in names of recipes (only). Page is the number of current
-- page on the list to show
-- SOURCE
function Show_Base_UI_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int with
Convention => C;
-- ****
function Show_Base_UI_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int is
pragma Unreferenced(ClientData);
BaseFrame: Ttk_Frame := Get_Widget(Main_Paned & ".baseframe", Interp);
BaseCanvas: constant Tk_Canvas :=
Get_Widget(BaseFrame & ".canvas", Interp);
SearchFrame: constant Ttk_Frame :=
Get_Widget(BaseCanvas & ".base.searchframe", Interp);
SearchEntry: constant Ttk_Entry :=
Get_Widget(SearchFrame & ".search", Interp);
FirstIndex, FormattedTime: Unbounded_String;
BaseIndex: constant Positive :=
SkyMap(Player_Ship.Sky_X, Player_Ship.Sky_Y).BaseIndex;
BaseType: constant Unbounded_String := Sky_Bases(BaseIndex).Base_Type;
Cost, Time: Natural := 0;
MoneyIndex2: constant Natural :=
FindItem(Player_Ship.Cargo, Money_Index);
MoneyLabel: constant Ttk_Label :=
Get_Widget(BaseCanvas & ".base.lblmoney", Interp);
Page: constant Positive :=
(if Argc = 4 then Positive'Value(CArgv.Arg(Argv, 3)) else 1);
Start_Row: constant Positive :=
((Page - 1) * Game_Settings.Lists_Limit) + 1;
Arguments: constant String :=
(if Argc > 2 then
"{" & CArgv.Arg(Argv, 1) & "} {" & CArgv.Arg(Argv, 2) & "}"
else CArgv.Arg(Argv, 1) & " {}");
Current_Row: Positive := 1;
procedure Format_Time is
begin
if Time < 60 then
FormattedTime :=
To_Unbounded_String(Natural'Image(Time) & " minute");
if Time > 1 then
Append(FormattedTime, "s");
end if;
else
FormattedTime :=
To_Unbounded_String(Positive'Image(Time / 60) & " hour");
if (Time / 60) > 1 then
Append(FormattedTime, "s");
end if;
if (Time mod 60) > 0 then
Append
(FormattedTime,
" and" & Positive'Image(Time mod 60) & " minute");
if (Time mod 60) > 1 then
Append(FormattedTime, "s");
end if;
end if;
end if;
end Format_Time;
function Get_Color(Cost: Positive) return String is
begin
if MoneyIndex2 = 0
or else Player_Ship.Cargo(MoneyIndex2).Amount < Cost then
return "red";
end if;
return "";
end Get_Color;
begin
if Winfo_Get(BaseCanvas, "exists") = "0" then
Tcl_EvalFile
(Get_Context,
To_String(Data_Directory) & "ui" & Dir_Separator & "base.tcl");
Bind(BaseFrame, "<Configure>", "{ResizeCanvas %W.canvas %w %h}");
elsif Winfo_Get(BaseCanvas, "ismapped") = "1" and Argc = 1 then
Tcl.Tk.Ada.Grid.Grid_Remove(Close_Button);
Entry_Configure(GameMenu, "Help", "-command {ShowHelp general}");
ShowSkyMap(True);
return TCL_OK;
end if;
BaseFrame.Name := New_String(BaseCanvas & ".base");
if Winfo_Get(Ttk_Frame'(Get_Widget(BaseFrame & ".table")), "exists") =
"1" then
Destroy(BaseTable.Canvas);
end if;
if CArgv.Arg(Argv, 1) /= "recipes" then
Tcl.Tk.Ada.Grid.Grid_Remove(SearchFrame);
BaseTable :=
CreateTable
(Widget_Image(BaseFrame),
(To_Unbounded_String("Action"), To_Unbounded_String("Cost"),
To_Unbounded_String("Time")),
Get_Widget(Main_Paned & ".baseframe.scrolly"),
"SortBaseItems " & CArgv.Arg(Argv, 1),
"Press mouse button to sort the actions.");
if CArgv.Arg(Argv, 1) = "heal"
and then Items_Indexes.Length /= Player_Ship.Crew.Length + 1 then
Items_Indexes.Clear;
for I in Player_Ship.Crew.Iterate loop
Items_Indexes.Append
(To_Unbounded_String
(Positive'Image(Crew_Container.To_Index(I))));
end loop;
Items_Indexes.Append(To_Unbounded_String("0"));
elsif CArgv.Arg(Argv, 1) = "repair"
and then Items_Indexes.Length /= Player_Ship.Modules.Length + 3 then
Items_Indexes.Clear;
for I in Player_Ship.Modules.Iterate loop
Items_Indexes.Append
(To_Unbounded_String
(Positive'Image(Modules_Container.To_Index(I))));
end loop;
Items_Indexes.Append(To_Unbounded_String("0"));
Items_Indexes.Append
(To_Unbounded_String
(if Sky_Bases(BaseIndex).Population > 149 then "-1"
else "-3"));
Items_Indexes.Append
(To_Unbounded_String
(if Sky_Bases(BaseIndex).Population > 299 then "-2"
else "-3"));
end if;
else
Tcl.Tk.Ada.Grid.Grid(SearchFrame);
if Argc /= 3 then
configure(SearchEntry, "-validatecommand {}");
Delete(SearchEntry, "0", "end");
configure(SearchEntry, "-validatecommand {SearchRecipes %P}");
end if;
BaseTable :=
CreateTable
(Widget_Image(BaseFrame),
(To_Unbounded_String("Name"), To_Unbounded_String("Cost"),
Null_Unbounded_String),
Get_Widget(Main_Paned & ".baseframe.scrolly"),
"SortBaseItems " & CArgv.Arg(Argv, 1),
"Press mouse button to sort the recipes.");
if Items_Indexes.Length /= Recipes_List.Length then
Items_Indexes.Clear;
for I in Recipes_List.Iterate loop
Items_Indexes.Append(Recipes_Container.Key(I));
end loop;
end if;
end if;
if MoneyIndex2 > 0 then
configure
(MoneyLabel,
"-text {You have" &
Natural'Image(Player_Ship.Cargo(MoneyIndex2).Amount) & " " &
To_String(Money_Name) & ".}");
else
configure
(MoneyLabel,
"-text {You don't have any " & To_String(Money_Name) &
" to buy anything.}");
end if;
if CArgv.Arg(Argv, 1) = "heal" then
Entry_Configure(GameMenu, "Help", "-command {ShowHelp crew}");
Show_Wounded_Crew_Loop :
for I of Items_Indexes loop
if Integer'Value(To_String(I)) > 0 then
if Player_Ship.Crew(Positive'Value(To_String(I))).Health =
100 then
goto End_Of_Wounded_Loop;
end if;
if FirstIndex = Null_Unbounded_String then
FirstIndex := I;
end if;
end if;
if Current_Row < Start_Row then
Current_Row := Current_Row + 1;
goto End_Of_Wounded_Loop;
end if;
Cost := 0;
Time := 0;
HealCost(Cost, Time, Positive'Value(To_String(I)));
AddButton
(BaseTable,
(if Integer'Value(To_String(I)) > 0 then
To_String
(Player_Ship.Crew(Positive'Value(To_String(I))).Name)
else "Heal all wounded crew members"),
"Show available options", "ShowBaseMenu heal" & To_String(I),
1);
AddButton
(Table => BaseTable,
Text => Positive'Image(Cost) & " " & To_String(Money_Name),
Tooltip => "Show available options",
Command => "ShowBaseMenu heal" & To_String(I), Column => 2,
Color => Get_Color(Cost));
Format_Time;
AddButton
(BaseTable, To_String(FormattedTime), "Show available options",
"ShowBaseMenu heal" & To_String(I), 3, True);
exit Show_Wounded_Crew_Loop when BaseTable.Row =
Game_Settings.Lists_Limit + 1;
<<End_Of_Wounded_Loop>>
end loop Show_Wounded_Crew_Loop;
elsif CArgv.Arg(Argv, 1) = "repair" then
Entry_Configure(GameMenu, "Help", "-command {ShowHelp ship}");
Show_Damaged_Modules_Loop :
for I of Items_Indexes loop
if Integer'Value(To_String(I)) > 0 then
if Player_Ship.Modules(Positive'Value(To_String(I)))
.Durability =
Player_Ship.Modules(Positive'Value(To_String(I)))
.Max_Durability then
goto End_Of_Damaged_Modules_Loop;
end if;
if FirstIndex = Null_Unbounded_String then
FirstIndex := I;
end if;
end if;
if Current_Row < Start_Row then
Current_Row := Current_Row + 1;
goto End_Of_Damaged_Modules_Loop;
end if;
if I = To_Unbounded_String("-3") then
goto End_Of_Damaged_Modules_Loop;
end if;
Cost := 0;
Time := 0;
Repair_Cost(Cost, Time, Integer'Value(To_String(I)));
Count_Price(Cost, FindMember(Talk));
AddButton
(BaseTable,
(case Integer'Value(To_String(I)) is
when 0 => "Slowly repair the whole ship",
when -1 => "Repair the whole ship",
when -2 => "Quickly repair the whole ship",
when others =>
To_String
(Player_Ship.Modules(Positive'Value(To_String(I)))
.Name)),
"Show available options", "ShowBaseMenu repair" & To_String(I),
1);
AddButton
(Table => BaseTable,
Text => Positive'Image(Cost) & " " & To_String(Money_Name),
Tooltip => "Show available options",
Command => "ShowBaseMenu repair" & To_String(I), Column => 2,
Color => Get_Color(Cost));
Format_Time;
AddButton
(BaseTable, To_String(FormattedTime), "Show available options",
"ShowBaseMenu repair" & To_String(I), 3, True);
exit Show_Damaged_Modules_Loop when BaseTable.Row =
Game_Settings.Lists_Limit + 1;
<<End_Of_Damaged_Modules_Loop>>
end loop Show_Damaged_Modules_Loop;
elsif CArgv.Arg(Argv, 1) = "recipes" then
Entry_Configure(GameMenu, "Help", "-command {ShowHelp craft}");
Show_Available_Recipes_Loop :
for I of Items_Indexes loop
if not Bases_Types_List(BaseType).Recipes.Contains(I) or
Known_Recipes.Find_Index(Item => I) /=
Positive_Container.No_Index or
Recipes_List(I).Reputation >
Sky_Bases(BaseIndex).Reputation(1) then
goto End_Of_Recipes_Loop;
end if;
if Argc > 2 and then CArgv.Arg(Argv, 2)'Length > 0
and then
Index
(To_Lower
(To_String(Items_List(Recipes_List(I).ResultIndex).Name)),
To_Lower(CArgv.Arg(Argv, 2))) =
0 then
goto End_Of_Recipes_Loop;
end if;
if FirstIndex = Null_Unbounded_String then
FirstIndex := I;
end if;
if Current_Row < Start_Row then
Current_Row := Current_Row + 1;
goto End_Of_Recipes_Loop;
end if;
AddButton
(BaseTable,
To_String(Items_List(Recipes_List(I).ResultIndex).Name),
"Show available options",
"ShowBaseMenu recipes {" & To_String(I) & "}", 1);
Cost :=
(if
Get_Price
(Sky_Bases(BaseIndex).Base_Type,
Recipes_List(I).ResultIndex) >
0
then
Get_Price
(Sky_Bases(BaseIndex).Base_Type,
Recipes_List(I).ResultIndex) *
Recipes_List(I).Difficulty * 10
else Recipes_List(I).Difficulty * 10);
Cost :=
Natural(Float(Cost) * Float(New_Game_Settings.Prices_Bonus));
if Cost = 0 then
Cost := 1;
end if;
Count_Price(Cost, FindMember(Talk));
AddButton
(Table => BaseTable,
Text => Positive'Image(Cost) & " " & To_String(Money_Name),
Tooltip => "Show available options",
Command => "ShowBaseMenu recipes {" & To_String(I) & "}",
Column => 2, NewRow => True, Color => Get_Color(Cost));
exit Show_Available_Recipes_Loop when BaseTable.Row =
Game_Settings.Lists_Limit + 1;
<<End_Of_Recipes_Loop>>
end loop Show_Available_Recipes_Loop;
end if;
AddPagination
(BaseTable,
(if Page > 1 then "ShowBaseUI " & Arguments & Positive'Image(Page - 1)
else ""),
(if BaseTable.Row < Game_Settings.Lists_Limit + 1 then ""
else "ShowBaseUI " & Arguments & Positive'Image(Page + 1)));
UpdateTable
(BaseTable, (if Focus = Widget_Image(SearchEntry) then False));
if FirstIndex = Null_Unbounded_String and Argc < 3 then
Tcl.Tk.Ada.Grid.Grid_Remove(Close_Button);
Entry_Configure(GameMenu, "Help", "-command {ShowHelp general}");
ShowSkyMap(True);
return TCL_OK;
end if;
Tcl.Tk.Ada.Grid.Grid(Close_Button, "-row 0 -column 1");
BaseFrame.Name := New_String(BaseCanvas & ".base");
configure
(BaseCanvas,
"-height [expr " & SashPos(Main_Paned, "0") & " - 20] -width " &
cget(Main_Paned, "-width"));
Tcl_Eval(Get_Context, "update");
Canvas_Create
(BaseCanvas, "window", "0 0 -anchor nw -window " & BaseFrame);
Tcl_Eval(Get_Context, "update");
configure
(BaseCanvas, "-scrollregion [list " & BBox(BaseCanvas, "all") & "]");
Show_Screen("baseframe");
Tcl_SetResult(Interp, "1");
return TCL_OK;
end Show_Base_UI_Command;
-- ****o* BUI/BUI.Base_Action_Command
-- FUNCTION
-- Execute the selected action
-- PARAMETERS
-- ClientData - Custom data send to the command.
-- Interp - Tcl interpreter in which command was executed.
-- Argc - Number of arguments passed to the command. Unused
-- Argv - Values of arguments passed to the command.
-- RESULT
-- This function always return TCL_OK
-- COMMANDS
-- BaseAction ActionType
-- ActionType can be heal, repair, recipes
-- SOURCE
function Base_Action_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int with
Convention => C;
-- ****
function Base_Action_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int is
pragma Unreferenced(Argc);
ItemIndex: constant String := CArgv.Arg(Argv, 2);
begin
if CArgv.Arg(Argv, 1) = "heal" then
HealWounded(Natural'Value(ItemIndex));
elsif CArgv.Arg(Argv, 1) = "repair" then
Bases.Ship.Repair_Ship(Integer'Value(ItemIndex));
elsif CArgv.Arg(Argv, 1) = "recipes" then
BuyRecipe(To_Unbounded_String(ItemIndex));
end if;
UpdateHeader;
Update_Messages;
return
Show_Base_UI_Command
(ClientData, Interp, 2,
CArgv.Empty & "ShowBaseUI" & CArgv.Arg(Argv, 1));
end Base_Action_Command;
-- ****o* BUI/BUI.Search_Recipes_Command
-- FUNCTION
-- Show only this recipes which contains the selected sequence
-- PARAMETERS
-- ClientData - Custom data send to the command.
-- Interp - Tcl interpreter in which command was executed.
-- Argc - Number of arguments passed to the command. Unused
-- Argv - Values of arguments passed to the command.
-- RESULT
-- This function always return TCL_OK
-- COMMANDS
-- SearchRecipes TextToSearch
-- SOURCE
function Search_Recipes_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int with
Convention => C;
-- ****
function Search_Recipes_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int is
pragma Unreferenced(Argc);
SearchText: constant String := CArgv.Arg(Argv, 1);
begin
if SearchText'Length = 0 then
return
Show_Base_UI_Command
(ClientData, Interp, 2, CArgv.Empty & "ShowBaseUI" & "recipes");
end if;
return
Show_Base_UI_Command
(ClientData, Interp, 3,
CArgv.Empty & "ShowBaseUI" & "recipes" & SearchText);
end Search_Recipes_Command;
-- ****o* BUI/BUI.Show_Base_Menu_Command
-- FUNCTION
-- Show menu with options for the selected item
-- PARAMETERS
-- ClientData - Custom data send to the command.
-- Interp - Tcl interpreter in which command was executed.
-- Argc - Number of arguments passed to the command. Unused
-- Argv - Values of arguments passed to the command.
-- RESULT
-- This function always return TCL_OK
-- COMMANDS
-- ShowBaseMenu action index
-- Action is name of action (heal,repair or recipe) and index is the index
-- of the item
-- SOURCE
function Show_Base_Menu_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int with
Convention => C;
-- ****
function Show_Base_Menu_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int is
pragma Unreferenced(ClientData, Argc);
BaseMenu: Tk_Menu := Get_Widget(".basemenu", Interp);
Cost, Time: Natural := 0;
BaseIndex: constant Positive :=
SkyMap(Player_Ship.Sky_X, Player_Ship.Sky_Y).BaseIndex;
MoneyIndex2: constant Natural :=
FindItem(Player_Ship.Cargo, Money_Index);
Action: constant String := CArgv.Arg(Argv, 1);
ItemIndex: constant String := CArgv.Arg(Argv, 2);
begin
if Winfo_Get(BaseMenu, "exists") = "0" then
BaseMenu := Create(".basemenu", "-tearoff false");
end if;
Delete(BaseMenu, "0", "end");
if Action = "heal" then
HealCost(Cost, Time, Integer'Value(ItemIndex));
elsif Action = "repair" then
Repair_Cost(Cost, Time, Integer'Value(ItemIndex));
Count_Price(Cost, FindMember(Talk));
else
Cost :=
(if
Get_Price
(Sky_Bases(BaseIndex).Base_Type,
Recipes_List(To_Unbounded_String(ItemIndex)).ResultIndex) >
0
then
Get_Price
(Sky_Bases(BaseIndex).Base_Type,
Recipes_List(To_Unbounded_String(ItemIndex)).ResultIndex) *
Recipes_List(To_Unbounded_String(ItemIndex)).Difficulty * 10
else Recipes_List(To_Unbounded_String(ItemIndex)).Difficulty * 10);
Cost := Natural(Float(Cost) * Float(New_Game_Settings.Prices_Bonus));
if Cost = 0 then
Cost := 1;
end if;
Count_Price(Cost, FindMember(Talk));
end if;
if MoneyIndex2 = 0
or else Player_Ship.Cargo(MoneyIndex2).Amount < Cost then
Menu.Add
(BaseMenu, "command", "-label {You don't have money for this}");
else
Menu.Add
(BaseMenu, "command",
"-label {" &
(if Action = "heal" then "Buy healing"
elsif Action = "repair" then "Buy repair" else "Buy recipe") &
"} -command {BaseAction " & Action & " " & ItemIndex & "}");
end if;
Tk_Popup
(BaseMenu, Winfo_Get(Get_Main_Window(Interp), "pointerx"),
Winfo_Get(Get_Main_Window(Interp), "pointery"));
return TCL_OK;
end Show_Base_Menu_Command;
-- ****it* BUI/BUI.Base_Sort_Orders
-- FUNCTION
-- Sorting orders for the crafting recipes/healing/repair in bases
-- OPTIONS
-- NAMEASC - Sort items by name ascending
-- NAMEDESC - Sort items by name descending
-- COSTASC - Sort items by cost ascending
-- COSTDESC - Sort items by cost descending
-- TIMEASC - Sort items by time ascending
-- TIMEDESC - Sort items by time descending
-- NONE - No sorting items (default)
-- HISTORY
-- 6.5 - Added
-- SOURCE
type Base_Sort_Orders is
(NAMEASC, NAMEDESC, COSTASC, COSTDESC, TIMEASC, TIMEDESC, NONE) with
Default_Value => NONE;
-- ****
-- ****id* BUI/BUI.Default_Base_Sort_Order
-- FUNCTION
-- Default sorting order for the items
-- HISTORY
-- 6.5 - Added
-- SOURCE
Default_Base_Sort_Order: constant Base_Sort_Orders := NONE;
-- ****
-- ****iv* BUI/BUI.Base_Sort_Order
-- FUNCTION
-- The current sorting order for items
-- HISTORY
-- 6.5 - Added
-- SOURCE
Base_Sort_Order: Base_Sort_Orders := Default_Base_Sort_Order;
-- ****
-- ****o* BUI/BUI.Sort_Modules_Command
-- FUNCTION
-- Sort the list with recipes to buy/healing wounded/repair ship
-- PARAMETERS
-- ClientData - Custom data send to the command.
-- Interp - Tcl interpreter in which command was executed.
-- Argc - Number of arguments passed to the command. Unused
-- Argv - Values of arguments passed to the command.
-- RESULT
-- This function always return TCL_OK
-- HISTORY
-- 6.5 - Added
-- COMMANDS
-- SortBaseItems x
-- X is X axis coordinate where the player clicked the mouse button
-- SOURCE
function Sort_Base_Items_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int with
Convention => C;
-- ****
function Sort_Base_Items_Command
(ClientData: Integer; Interp: Tcl.Tcl_Interp; Argc: Interfaces.C.int;
Argv: CArgv.Chars_Ptr_Ptr) return Interfaces.C.int is
pragma Unreferenced(Argc);
Column: constant Positive :=
Get_Column_Number(BaseTable, Natural'Value(CArgv.Arg(Argv, 2)));
type Local_Item_Data is record
Name: Unbounded_String;
Cost: Positive;
Time: Positive;
Id: Unbounded_String;
end record;
type Items_Array is array(Positive range <>) of Local_Item_Data;
BaseIndex: constant Positive :=
SkyMap(Player_Ship.Sky_X, Player_Ship.Sky_Y).BaseIndex;
Local_Items: Items_Array
(1 ..
(if CArgv.Arg(Argv, 1) = "recipes" then
Positive(Recipes_List.Length)
elsif CArgv.Arg(Argv, 1) = "heal" then
Positive(Player_Ship.Crew.Length) + 1
else Positive(Player_Ship.Modules.Length) +
(if Sky_Bases(BaseIndex).Population > 299 then 3
elsif Sky_Bases(BaseIndex).Population > 149 then 2 else 1)));
Index: Positive := 1;
Cost, Time: Natural := 0;
function "<"(Left, Right: Local_Item_Data) return Boolean is
begin
if Base_Sort_Order = NAMEASC and then Left.Name < Right.Name then
return True;
end if;
if Base_Sort_Order = NAMEDESC and then Left.Name > Right.Name then
return True;
end if;
if Base_Sort_Order = COSTASC and then Left.Cost < Right.Cost then
return True;
end if;
if Base_Sort_Order = COSTDESC and then Left.Cost > Right.Cost then
return True;
end if;
if Base_Sort_Order = TIMEASC and then Left.Time < Right.Time then
return True;
end if;
if Base_Sort_Order = TIMEDESC and then Left.Time > Right.Time then
return True;
end if;
return False;
end "<";
procedure Sort_Items is new Ada.Containers.Generic_Array_Sort
(Index_Type => Positive, Element_Type => Local_Item_Data,
Array_Type => Items_Array);
procedure Count_Repair_Cost(Index: Integer) is
begin
Cost := 0;
Time := 0;
Repair_Cost(Cost, Time, Index);
Count_Price(Cost, FindMember(Talk));
end Count_Repair_Cost;
begin
case Column is
when 1 =>
if Base_Sort_Order = NAMEASC then
Base_Sort_Order := NAMEDESC;
else
Base_Sort_Order := NAMEASC;
end if;
when 2 =>
if Base_Sort_Order = COSTASC then
Base_Sort_Order := COSTDESC;
else
Base_Sort_Order := COSTASC;
end if;
when 3 =>
if Base_Sort_Order = TIMEASC then
Base_Sort_Order := TIMEDESC;
else
Base_Sort_Order := TIMEASC;
end if;
when others =>
null;
end case;
if Base_Sort_Order = NONE then
return TCL_OK;
end if;
if CArgv.Arg(Argv, 1) = "heal" then
for I in Player_Ship.Crew.Iterate loop
Cost := 0;
Time := 0;
HealCost(Cost, Time, Crew_Container.To_Index(I));
Local_Items(Crew_Container.To_Index(I)) :=
(Name => Player_Ship.Crew(I).Name, Cost => Cost, Time => Time,
Id =>
To_Unbounded_String
(Positive'Image(Crew_Container.To_Index(I))));
end loop;
Cost := 0;
Time := 0;
HealCost(Cost, Time, 0);
Local_Items(Local_Items'Last) :=
(Name => To_Unbounded_String("Heal all wounded crew members"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("0"));
elsif CArgv.Arg(Argv, 1) = "repair" then
for I in Player_Ship.Modules.Iterate loop
Count_Repair_Cost(Modules_Container.To_Index(I));
Local_Items(Modules_Container.To_Index(I)) :=
(Name => Player_Ship.Modules(I).Name, Cost => Cost, Time => Time,
Id =>
To_Unbounded_String
(Positive'Image(Modules_Container.To_Index(I))));
end loop;
if Sky_Bases(BaseIndex).Population > 299 then
Count_Repair_Cost(0);
Local_Items(Local_Items'Last - 2) :=
(Name => To_Unbounded_String("Slowly repair the whole ship"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("0"));
Count_Repair_Cost(-1);
Local_Items(Local_Items'Last - 1) :=
(Name => To_Unbounded_String("Repair the whole ship"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("-1"));
Count_Repair_Cost(-2);
Local_Items(Local_Items'Last) :=
(Name => To_Unbounded_String("Quickly repair the whole ship"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("-2"));
elsif Sky_Bases(BaseIndex).Population > 149 then
Count_Repair_Cost(0);
Local_Items(Local_Items'Last - 1) :=
(Name => To_Unbounded_String("Slowly repair the whole ship"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("0"));
Count_Repair_Cost(-1);
Local_Items(Local_Items'Last) :=
(Name => To_Unbounded_String("Repair the whole ship"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("-1"));
else
Count_Repair_Cost(0);
Local_Items(Local_Items'Last) :=
(Name => To_Unbounded_String("Slowly repair the whole ship"),
Cost => Cost, Time => Time, Id => To_Unbounded_String("0"));
end if;
elsif CArgv.Arg(Argv, 1) = "recipes" then
for I in Recipes_List.Iterate loop
Cost :=
(if
Get_Price
(Sky_Bases(BaseIndex).Base_Type,
Recipes_List(I).ResultIndex) >
0
then
Get_Price
(Sky_Bases(BaseIndex).Base_Type,
Recipes_List(I).ResultIndex) *
Recipes_List(I).Difficulty * 10
else Recipes_List(I).Difficulty * 10);
Cost :=
Natural(Float(Cost) * Float(New_Game_Settings.Prices_Bonus));
if Cost = 0 then
Cost := 1;
end if;
Count_Price(Cost, FindMember(Talk));
Local_Items(Index) :=
(Name => Items_List(Recipes_List(I).ResultIndex).Name,
Cost => Cost, Time => 1, Id => Recipes_Container.Key(I));
Index := Index + 1;
end loop;
end if;
Sort_Items(Local_Items);
Items_Indexes.Clear;
for Item of Local_Items loop
Items_Indexes.Append(Item.Id);
end loop;
return
Show_Base_UI_Command
(ClientData, Interp, 2,
CArgv.Empty & "ShowBaseUI" & CArgv.Arg(Argv, 1));
end Sort_Base_Items_Command;
procedure AddCommands is
begin
Add_Command("ShowBaseUI", Show_Base_UI_Command'Access);
Add_Command("BaseAction", Base_Action_Command'Access);
Add_Command("SearchRecipes", Search_Recipes_Command'Access);
Add_Command("ShowBaseMenu", Show_Base_Menu_Command'Access);
Add_Command("SortBaseItems", Sort_Base_Items_Command'Access);
end AddCommands;
end Bases.UI;
|
src/Relation/Ternary/Separation/Monad/Delay.agda | laMudri/linear.agda | 34 | 12756 | <filename>src/Relation/Ternary/Separation/Monad/Delay.agda<gh_stars>10-100
module Relation.Ternary.Separation.Monad.Delay where
open import Level
open import Function
open import Function using (_∘_; case_of_)
open import Relation.Binary.PropositionalEquality
open import Relation.Unary
open import Relation.Unary.PredicateTransformer hiding (_⊔_)
open import Relation.Ternary.Separation
open import Relation.Ternary.Separation.Monad
open import Relation.Ternary.Separation.Morphisms
open import Codata.Delay as D using (now; later) public
open import Data.Unit
open Monads
module _ {ℓ}
{C : Set ℓ} {u}
{{r : RawSep C}}
{{us : IsUnitalSep r u}}
where
Delay : ∀ {ℓ} i → Pt C ℓ
Delay i P c = D.Delay (P c) i
instance
delay-monad : ∀ {i} → Monad ⊤ ℓ (λ _ _ → Delay i)
Monad.return delay-monad px = D.now px
app (Monad.bind delay-monad f) ►px σ = D.bind ►px λ px → app f px σ
|
oeis/268/A268933.asm | neoneye/loda-programs | 11 | 23298 | ; A268933: Permutation of nonnegative integers: a(0) = 0, for n >= 1, a(n) = A268717(1 + A268831(n-1)).
; Submitted by <NAME>
; 0,1,3,2,6,7,5,4,12,15,13,9,11,14,10,29,31,26,30,8,24,27,25,53,55,50,54,16,48,51,49,28,20,23,21,17,19,22,18,101,103,98,102,32,96,99,97,44,36,39,37,33,35,38,34,52,60,63,61,57,59,62,58,45,47,42,46,56,40,43,41,197,199,194,198,64,192,195,193,76,68,71,69,65,67,70,66,84,92,95,93,89,91,94,90,77,79,74,78,88
mov $1,$0
trn $0,1
seq $0,268831 ; Permutation of nonnegative integers: a(0) = 0, a(n) = A268717(1+A268827(n-1)).
add $0,1
seq $0,268717 ; Permutation of natural numbers: a(0) = 0, a(n) = A003188(1+A006068(n-1)), where A003188 is binary Gray code and A006068 is its inverse.
cmp $1,0
cmp $1,0
mul $0,$1
|
programs/oeis/001/A001650.asm | karttu/loda | 0 | 170186 | <gh_stars>0
; A001650: n appears n times (n odd).
; 1,3,3,3,5,5,5,5,5,7,7,7,7,7,7,7,9,9,9,9,9,9,9,9,9,11,11,11,11,11,11,11,11,11,11,11,13,13,13,13,13,13,13,13,13,13,13,13,13,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,19,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,23,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,25,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,27,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31
add $0,1
lpb $0,1
add $1,2
sub $0,$1
lpe
add $1,1
|
programs/oeis/180/A180713.asm | karttu/loda | 1 | 178449 | ; A180713: If n is even then a(n) = 3n, if n == 1 mod 4 then a(n) = 3n+1, if n == 3 mod 4 then a(n) = 3n+2.
; 0,4,6,11,12,16,18,23,24,28,30,35,36,40,42,47,48,52,54,59,60,64,66,71,72,76,78,83,84,88,90,95,96,100,102,107,108,112,114,119,120,124,126,131,132,136,138,143,144,148,150,155,156,160,162,167,168,172,174,179,180,184,186,191,192,196,198,203,204,208,210,215,216,220,222,227,228,232,234,239,240,244,246,251,252,256,258,263,264,268,270,275,276,280,282,287,288,292,294,299,300,304,306,311,312,316,318,323,324,328,330,335,336,340,342,347,348,352,354,359,360,364,366,371,372,376,378,383,384,388,390,395,396,400,402,407,408,412,414,419,420,424,426,431,432,436,438,443,444,448,450,455,456,460,462,467,468,472,474,479,480,484,486,491,492,496,498,503,504,508,510,515,516,520,522,527,528,532,534,539,540,544,546,551,552,556,558,563,564,568,570,575,576,580,582,587,588,592,594,599,600,604,606,611,612,616,618,623,624,628,630,635,636,640,642,647,648,652,654,659,660,664,666,671,672,676,678,683,684,688,690,695,696,700,702,707,708,712,714,719,720,724,726,731,732,736,738,743,744,748
mov $1,4
mov $3,$0
add $0,1
gcd $1,$0
div $1,2
mov $2,$3
mul $2,3
add $1,$2
|
programs/oeis/143/A143998.asm | karttu/loda | 1 | 99722 | <gh_stars>1-10
; A143998: Rectangular array by antidiagonals: label each unit square in the first quadrant lattice by its northeast vertex (x,y) and mark squares for which (x,y) is congruent mod 4 to one of the following: (1,1), (2,3), (3,2), (4,0); then R(m,n) is the number of marked squares in the rectangle [0,m]x[0,n].
; 0,1,1,2,3,2,3,4,4,3,3,6,6,6,3,4,7,9,9,7,4,5,9,11,12,11,9,5,6,10,13,15,15,13,10,6,6,12,15,18,18,18,15,12,6,7,13,18,21,22,22,21,18,13,7,8,15,20,24,26,27,26,24,20,15,8,9,16,22,27,30,31,31,30,27,22,16,9,9,18,24,30,33,36,36,36,33,30,24,18,9,10,19,27,33,37,40,42,42,40,37,33,27,19,10,11,21,29,36,41,45,47,48,47,45,41,36,29,21,11,12,22,31,39,45,49,52,54,54,52,49,45,39,31,22,12,12,24,33,42,48,54,57,60,60,60,57,54,48,42,33,24,12,13,25,36,45,52,58,63,66,67,67,66,63,58,52,45,36,25,13,14,27,38,48,56,63,68,72,74,75,74,72,68,63,56,48,38,27,14,15,28,40,51,60,67,73,78,81,82,82,81,78,73,67,60,51,40,28,15,15,30,42,54,63,72,78,84,87,90,90,90,87,84,78,72,63,54,42,30,15,16,31,45,57,67,76,84,90,94,97,99,99,97,94,90,84,76,67,57
cal $0,59036 ; In a triangle of numbers (such as that in A059032, A059033, A059034) how many entries lie above position (n,k)? Answer: T(n,k) = (n+1)*(k+1)-1 (n >= 0, k >= 0).
mov $1,$0
div $0,2
mov $2,$1
add $1,1
add $1,$2
sub $1,$0
div $1,2
|
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/c4/c43214f.ada | best08618/asylo | 7 | 21737 | <gh_stars>1-10
-- C43214F.ADA
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
-- CHECK THAT THE LOWER BOUND FOR THE STRING LITERAL IS DETERMINED BY
-- THE APPLICABLE INDEX CONSTRAINT, WHEN ONE EXISTS.
-- EG 02/10/84
-- JBG 3/30/84
WITH REPORT;
PROCEDURE C43214F IS
USE REPORT;
BEGIN
TEST("C43214F", "ARRAY COMPONENT EXPRESSION OF AN ENCLOSING " &
"AGGREGATE");
BEGIN
CASE_E : BEGIN
-- COMMENT ("CASE E1 : ARRAY COMPONENT EXPRESSION OF " &
-- "AN ENCLOSING ARRAY AGGREGATE");
CASE_E1 : DECLARE
TYPE TE2 IS ARRAY(1 .. 2) OF
STRING(IDENT_INT(3) .. 5);
E1 : TE2;
BEGIN
E1 := (1 .. 2 => "ABC");
IF (E1'FIRST /= 1 OR E1'LAST /= 2) OR ELSE
(E1(1)'FIRST /= 3 OR E1(1)'LAST /= 5 OR
E1(2)'FIRST /= 3 OR E1(2)'LAST /= 5) THEN
FAILED ("CASE 1 : INCORRECT BOUNDS");
ELSIF E1 /= (1 .. 2 => "ABC") THEN
FAILED ("CASE 1 : ARRAY DOES NOT " &
"CONTAIN THE CORRECT VALUES");
END IF;
END CASE_E1;
-- COMMENT ("CASE E2 : ARRAY COMPONENT EXPRESSION OF " &
-- "AN ENCLOSING RECORD AGGREGATE");
CASE_E2 : DECLARE
TYPE TER IS
RECORD
REC : STRING(3 .. 5);
END RECORD;
E2 : TER;
BEGIN
E2 := (REC => "ABC");
IF E2.REC'FIRST /= 3 OR E2.REC'LAST /= 5 THEN
FAILED ("CASE 2 : INCORRECT BOUNDS");
ELSIF E2.REC /= "ABC" THEN
FAILED ("CASE 2 : ARRAY DOES NOT " &
"CONTAIN CORRECT VALUES");
END IF;
END CASE_E2;
-- COMMENT ("CASE E3 : NULL LITERAL OF AN ENCLOSING " &
-- "ARRAY AGGREGATE");
CASE_E3 : DECLARE
TYPE TE2 IS ARRAY(1 .. 2) OF
STRING(3 .. IDENT_INT(2));
E3 : TE2;
BEGIN
E3 := (1 .. 2 => "");
IF (E3'FIRST /= 1 OR E3'LAST /= 2) OR ELSE
(E3(1)'FIRST /= 3 OR E3(1)'LAST /= 2 OR
E3(2)'FIRST /= 3 OR E3(2)'LAST /= 2) THEN
FAILED ("CASE 3 : INCORRECT BOUND");
ELSIF E3 /= (1 .. 2 => "") THEN
FAILED ("CASE 3 : ARRAY DOES NOT CONTAIN " &
"THE CORRECT VALUES");
END IF;
END CASE_E3;
-- COMMENT ("CASE E4 : ARRAY COMPONENT EXPRESSION OF " &
-- "AN ENCLOSING RECORD AGGREGATE THAT HAS A " &
-- "DISCRIMINANT AND THE DISCRIMINANT DETER" &
-- "MINES THE BOUNDS OF THE COMPONENT");
CASE_E4 : DECLARE
SUBTYPE TEN IS INTEGER RANGE 1 .. 10;
TYPE TER (A : TEN) IS
RECORD
REC : STRING(3 .. A);
END RECORD;
E4 : TER(5);
BEGIN
E4 := (REC => "ABC", A => 5);
IF E4.REC'FIRST /= 3 OR E4.REC'LAST /= 5 THEN
FAILED ("CASE 4 : INCORRECT BOUNDS");
ELSIF E4.REC /= "ABC" THEN
FAILED ("CASE 4 : ARRAY DOES NOT CONTAIN " &
"CORRECT VALUES");
END IF;
END CASE_E4;
END CASE_E;
END;
RESULT;
END C43214F;
|
Task/Execute-a-system-command/AppleScript/execute-a-system-command.applescript | LaudateCorpus1/RosettaCodeData | 1 | 4361 | <filename>Task/Execute-a-system-command/AppleScript/execute-a-system-command.applescript
do shell script "ls" without altering line endings
|
awa/src/awa-permissions-controllers.ads | fuzzysloth/ada-awa | 81 | 12292 | -----------------------------------------------------------------------
-- awa-permissions-controllers -- Permission controllers
-- Copyright (C) 2011, 2012, 2013, 2014 <NAME>
-- Written by <NAME> (<EMAIL>)
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Security.Contexts;
with Security.Controllers;
package AWA.Permissions.Controllers is
-- ------------------------------
-- Security Controller
-- ------------------------------
-- The <b>Entity_Controller</b> implements an entity based permission check.
-- The controller is configured through an XML description. It uses an SQL statement
-- to verify that a permission is granted.
--
-- The SQL query can use the following query parameters:
--
-- <dl>
-- <dt>entity_type</dt>
-- <dd>The entity type identifier defined by the entity permission</dd>
-- <dt>entity_id</dt>
-- <dd>The entity identifier which is associated with an <b>ACL</b> entry to check</dd>
-- <dt>user_id</dt>
-- <dd>The user identifier</dd>
-- </dl>
type Entity_Controller (Len : Positive) is
limited new Security.Controllers.Controller with record
Entities : Entity_Type_Array;
SQL : String (1 .. Len);
end record;
type Entity_Controller_Access is access all Entity_Controller'Class;
-- Returns true if the user associated with the security context <b>Context</b> has
-- the permission to access a database entity. The security context contains some
-- information about the entity to check and the permission controller will use an
-- SQL statement to verify the permission.
overriding
function Has_Permission (Handler : in Entity_Controller;
Context : in Security.Contexts.Security_Context'Class;
Permission : in Security.Permissions.Permission'Class)
return Boolean;
end AWA.Permissions.Controllers;
|
Units.Core.Parser/Grammar/UnitsGrammar.g4 | branc116/units-core | 1 | 5744 | grammar UnitsGrammar;
prog: (statments NEW_LINE_SYMBOLS?)+;
statments: newUnit_Binary
| newUnit_Unary
| command
| expr
| operator
| comment ;
comment:
'#' ~('#') '#';
newUnit_Binary: WORD DEF WORD VALID_OPERATORS WORD ;
newUnit_Unary: WORD DEF (VALID_OPERATORS | WORD) WORD ;
command: '!' unitName argslist;
operator: unitName '(' (VALID_OPERATORS | LETTER | WORD) ')' DEF operatorDefs;
operatorDefs: operatorDef '|' operatorDefs
| operatorDef ;
operatorDef: operatorDef_Binary
| operatorDef_Unary;
operatorDef_Binary: LETTER '=' LETTER VALID_OPERATORS LETTER;
operatorDef_Unary: LETTER '=' (LETTER | WORD) LETTER ;
expr: left DEF argslist ;
left: unitName '(' unitName ')' ;
argslist: '(' args ')' ARGSSEP argslist
| '(' args ')'
| args_esc ARGSSEP argslist
| args_esc
| '{' args_esc '}' ARGSSEP argslist
| '{' args_esc '}' ;
args: arg COMA args
| arg ;
args_esc: arg_esc COMA args_esc
| arg_esc ;
arg: (arg_common)*;
arg_esc: (arg_common | '(' | ')')*;
arg_common: SYM_FLOAT | NUM_FLOAT | unitName | VALID_OPERATORS | '˙'| '.';
unitName: WORD | LETTER;
SYM_FLOAT: NUM_FLOAT LETTER;
NUM_FLOAT: NUM_INT '.'?
| NUM_INT? '.' NUM_INT
| NUM_INT '.'? ('e' | 'E') ('-' | '+') NUM_INT
| NUM_INT? '.' NUM_INT ('e' | 'E') ('-' | '+') NUM_INT ;
NUM_INT: NUMBER_SYMBOLS+;
WS_SYMBOLS: (' ' | '\t') -> skip;
NEW_LINE_SYMBOLS: ('\n' | '\r')+;
VALID_OPERATORS: '*' | '+' | '-' | '/' | '<=' | '>=' | '<' | '>' | '==' | '!=' ;
NUMBER_SYMBOLS: '0'..'9' ;
LETTER: 'a'..'z' | 'A'..'Z' ;
WORD: (LETTER | NUMBER_SYMBOLS)+;
DEF: ':=' ;
COMA: ',' ;
ARGSSEP: '|'; |
ada-numerics.ads | mgrojo/adalib | 15 | 10797 | <filename>ada-numerics.ads
-- Standard Ada library specification
-- Copyright (c) 2003-2018 <NAME> <<EMAIL>>
-- Copyright (c) 2004-2016 AXE Consultants
-- Copyright (c) 2004, 2005, 2006 Ada-Europe
-- Copyright (c) 2000 The MITRE Corporation, Inc.
-- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc.
-- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual
---------------------------------------------------------------------------
package Ada.Numerics is
pragma Pure (Numerics);
Argument_Error : exception;
Pi : constant :=
3.14159_26535_89793_23846_26433_83279_50288_41971_69399_37511;
π : constant := Pi;
e : constant :=
2.71828_18284_59045_23536_02874_71352_66249_77572_47093_69996;
end Ada.Numerics;
|
orka/src/gl/interface/gl-pixels.ads | onox/orka | 52 | 15574 | -- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (c) 2012 <NAME> <<EMAIL>>
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
with GL.Types;
private with GL.Low_Level;
package GL.Pixels is
pragma Preelaborate;
use GL.Types;
type Internal_Format_Buffer_Texture is (RGBA8, RGBA16, R8, R16, RG8, RG16, R16F,
R32F, RG16F, RG32F,
R8I, R8UI, R16I, R16UI, R32I, R32UI,
RG8I, RG8UI, RG16I, RG16UI, RG32I, RG32UI,
RGBA32F, RGB32F, RGBA16F, RGB16F,
RGBA32UI, RGB32UI, RGBA16UI, RGBA8UI,
RGBA32I, RGB32I, RGBA16I, RGBA8I);
type Internal_Format is (R3_G3_B2, RGB4, RGB5, RGB8, RGB10, RGB12, RGB16,
RGBA2, RGBA4, RGB5_A1, RGBA8, RGB10_A2, RGBA12, RGBA16,
Depth_Component16, Depth_Component24,
R8, R16, RG8, RG16, R16F, R32F, RG16F, RG32F,
R8I, R8UI, R16I, R16UI, R32I, R32UI,
RG8I, RG8UI, RG16I, RG16UI, RG32I, RG32UI,
RGBA32F, RGB32F, RGBA16F, RGB16F,
Depth24_Stencil8, R11F_G11F_B10F, RGB9_E5,
SRGB8, SRGB8_Alpha8,
Depth_Component32F, Depth32F_Stencil8, Stencil_Index8,
RGBA32UI, RGB32UI, RGBA16UI, RGB16UI, RGBA8UI, RGB8UI,
RGBA32I, RGB32I, RGBA16I, RGB16I, RGBA8I, RGB8I,
R8_SNorm, RG8_SNorm, RGB8_SNorm, RGBA8_SNorm,
R16_SNorm, RG16_SNorm, RGB16_SNorm, RGBA16_SNorm, RGB10_A2UI);
-- Table 8.12 of the OpenGL specification
type Compressed_Format is
(Compressed_Red_RGTC1,
Compressed_Signed_Red_RGTC1,
Compressed_RG_RGTC2,
Compressed_Signed_RG_RGTC2,
Compressed_RGBA_BPTC_Unorm,
Compressed_SRGB_Alpha_BPTC_UNorm,
Compressed_RGB_BPTC_Signed_Float,
Compressed_RGB_BPTC_Unsigned_Float,
Compressed_R11_EAC,
Compressed_Signed_R11_EAC,
Compressed_RG11_EAC,
Compressed_Signed_RG11_EAC,
Compressed_RGB8_ETC2,
Compressed_SRGB8_ETC2,
Compressed_RGB8_Punchthrough_Alpha1_ETC2,
Compressed_SRGB8_Punchthrough_Alpha1_ETC2,
Compressed_RGBA8_ETC2_EAC,
Compressed_SRGB8_Alpha8_ETC2_EAC,
-- ASTC (not part of OpenGL core)
Compressed_RGBA_ASTC_4x4_KHR,
Compressed_RGBA_ASTC_5x4_KHR,
Compressed_RGBA_ASTC_5x5_KHR,
Compressed_RGBA_ASTC_6x5_KHR,
Compressed_RGBA_ASTC_6x6_KHR,
Compressed_RGBA_ASTC_8x5_KHR,
Compressed_RGBA_ASTC_8x6_KHR,
Compressed_RGBA_ASTC_8x8_KHR,
Compressed_RGBA_ASTC_10x5_KHR,
Compressed_RGBA_ASTC_10x6_KHR,
Compressed_RGBA_ASTC_10x8_KHR,
Compressed_RGBA_ASTC_10x10_KHR,
Compressed_RGBA_ASTC_12x10_KHR,
Compressed_RGBA_ASTC_12x12_KHR,
Compressed_SRGB8_ALPHA8_ASTC_4x4_KHR,
Compressed_SRGB8_ALPHA8_ASTC_5x4_KHR,
Compressed_SRGB8_ALPHA8_ASTC_5x5_KHR,
Compressed_SRGB8_ALPHA8_ASTC_6x5_KHR,
Compressed_SRGB8_ALPHA8_ASTC_6x6_KHR,
Compressed_SRGB8_ALPHA8_ASTC_8x5_KHR,
Compressed_SRGB8_ALPHA8_ASTC_8x6_KHR,
Compressed_SRGB8_ALPHA8_ASTC_8x8_KHR,
Compressed_SRGB8_ALPHA8_ASTC_10x5_KHR,
Compressed_SRGB8_ALPHA8_ASTC_10x6_KHR,
Compressed_SRGB8_ALPHA8_ASTC_10x8_KHR,
Compressed_SRGB8_ALPHA8_ASTC_10x10_KHR,
Compressed_SRGB8_ALPHA8_ASTC_12x10_KHR,
Compressed_SRGB8_ALPHA8_ASTC_12x12_KHR);
-- Specific compressed internal formats of Table 8.14 of the OpenGL specification
type Format is (Stencil_Index, Depth_Component, Red, Green, Blue,
RGB, RGBA, BGR, BGRA, RG, RG_Integer, Depth_Stencil,
Red_Integer, Green_Integer, Blue_Integer,
RGB_Integer, RGBA_Integer, BGR_Integer, BGRA_Integer);
-- Table 8.3 of the OpenGL specification
type Data_Type is (Byte, Unsigned_Byte, Short, Unsigned_Short, Int,
Unsigned_Int, Float, Half_Float, Unsigned_Byte_3_3_2,
Unsigned_Short_4_4_4_4,
Unsigned_Short_5_5_5_1,
Unsigned_Int_8_8_8_8,
Unsigned_Int_10_10_10_2,
Unsigned_Byte_2_3_3_Rev,
Unsigned_Short_5_6_5,
Unsigned_Short_5_6_5_Rev,
Unsigned_Short_4_4_4_4_Rev,
Unsigned_Short_1_5_5_5_Rev,
Unsigned_Int_8_8_8_8_Rev,
Unsigned_Int_2_10_10_10_Rev,
Unsigned_Int_24_8,
Unsigned_Int_10F_11F_11F_Rev,
Unsigned_Int_5_9_9_9_Rev,
Float_32_Unsigned_Int_24_8_Rev);
-- Table 8.2 of the OpenGL specification
type Channel_Data_Type is (None, Int_Type, Unsigned_Int_Type, Float_Type,
Unsigned_Normalized, Signed_Normalized);
type Alignment is (Bytes, Even_Bytes, Words, Double_Words);
procedure Set_Pack_Alignment (Value : Alignment);
function Pack_Alignment return Alignment;
procedure Set_Pack_Compressed_Block_Width (Value : Size);
procedure Set_Pack_Compressed_Block_Height (Value : Size);
procedure Set_Pack_Compressed_Block_Depth (Value : Size);
procedure Set_Pack_Compressed_Block_Size (Value : Size);
function Pack_Compressed_Block_Width return Size;
function Pack_Compressed_Block_Height return Size;
function Pack_Compressed_Block_Depth return Size;
function Pack_Compressed_Block_Size return Size;
procedure Set_Unpack_Alignment (Value : Alignment);
function Unpack_Alignment return Alignment;
procedure Set_Unpack_Compressed_Block_Width (Value : Size);
procedure Set_Unpack_Compressed_Block_Height (Value : Size);
procedure Set_Unpack_Compressed_Block_Depth (Value : Size);
procedure Set_Unpack_Compressed_Block_Size (Value : Size);
function Unpack_Compressed_Block_Width return Size;
function Unpack_Compressed_Block_Height return Size;
function Unpack_Compressed_Block_Depth return Size;
function Unpack_Compressed_Block_Size return Size;
private
for Internal_Format_Buffer_Texture use (RGBA8 => 16#8058#,
RGBA16 => 16#805B#,
R8 => 16#8229#,
R16 => 16#822A#,
RG8 => 16#822B#,
RG16 => 16#822C#,
R16F => 16#822D#,
R32F => 16#822E#,
RG16F => 16#822F#,
RG32F => 16#8230#,
R8I => 16#8231#,
R8UI => 16#8232#,
R16I => 16#8233#,
R16UI => 16#8234#,
R32I => 16#8235#,
R32UI => 16#8236#,
RG8I => 16#8237#,
RG8UI => 16#8238#,
RG16I => 16#8239#,
RG16UI => 16#823A#,
RG32I => 16#823B#,
RG32UI => 16#823C#,
RGBA32F => 16#8814#,
RGB32F => 16#8815#,
RGBA16F => 16#881A#,
RGB16F => 16#881B#,
RGBA32UI => 16#8D70#,
RGB32UI => 16#8D71#,
RGBA16UI => 16#8D76#,
RGBA8UI => 16#8D7C#,
RGBA32I => 16#8D82#,
RGB32I => 16#8D83#,
RGBA16I => 16#8D88#,
RGBA8I => 16#8D8E#);
for Internal_Format_Buffer_Texture'Size use Low_Level.Enum'Size;
for Internal_Format use (R3_G3_B2 => 16#2A10#,
RGB4 => 16#804F#,
RGB5 => 16#8050#,
RGB8 => 16#8051#,
RGB10 => 16#8052#,
RGB12 => 16#8053#,
RGB16 => 16#8054#,
RGBA2 => 16#8055#,
RGBA4 => 16#8056#,
RGB5_A1 => 16#8057#,
RGBA8 => 16#8058#,
RGB10_A2 => 16#8059#,
RGBA12 => 16#805A#,
RGBA16 => 16#805B#,
Depth_Component16 => 16#81A5#,
Depth_Component24 => 16#81A6#,
R8 => 16#8229#,
R16 => 16#822A#,
RG8 => 16#822B#,
RG16 => 16#822C#,
R16F => 16#822D#,
R32F => 16#822E#,
RG16F => 16#822F#,
RG32F => 16#8230#,
R8I => 16#8231#,
R8UI => 16#8232#,
R16I => 16#8233#,
R16UI => 16#8234#,
R32I => 16#8235#,
R32UI => 16#8236#,
RG8I => 16#8237#,
RG8UI => 16#8238#,
RG16I => 16#8239#,
RG16UI => 16#823A#,
RG32I => 16#823B#,
RG32UI => 16#823C#,
RGBA32F => 16#8814#,
RGB32F => 16#8815#,
RGBA16F => 16#881A#,
RGB16F => 16#881B#,
Depth24_Stencil8 => 16#88F0#,
R11F_G11F_B10F => 16#8C3A#,
RGB9_E5 => 16#8C3D#,
SRGB8 => 16#8C41#,
SRGB8_Alpha8 => 16#8C43#,
Depth_Component32F => 16#8CAC#,
Depth32F_Stencil8 => 16#8CAD#,
Stencil_Index8 => 16#8D48#,
RGBA32UI => 16#8D70#,
RGB32UI => 16#8D71#,
RGBA16UI => 16#8D76#,
RGB16UI => 16#8D77#,
RGBA8UI => 16#8D7C#,
RGB8UI => 16#8D7D#,
RGBA32I => 16#8D82#,
RGB32I => 16#8D83#,
RGBA16I => 16#8D88#,
RGB16I => 16#8D89#,
RGBA8I => 16#8D8E#,
RGB8I => 16#8D8F#,
R8_SNorm => 16#8F94#,
RG8_SNorm => 16#8F95#,
RGB8_SNorm => 16#8F96#,
RGBA8_SNorm => 16#8F97#,
R16_SNorm => 16#8F98#,
RG16_SNorm => 16#8F99#,
RGB16_SNorm => 16#8F9A#,
RGBA16_SNorm => 16#8F9B#,
RGB10_A2UI => 16#906F#);
for Internal_Format'Size use Low_Level.Enum'Size;
for Compressed_Format use
(Compressed_Red_RGTC1 => 16#8DBB#,
Compressed_Signed_Red_RGTC1 => 16#8DBC#,
Compressed_RG_RGTC2 => 16#8DBD#,
Compressed_Signed_RG_RGTC2 => 16#8DBE#,
Compressed_RGBA_BPTC_Unorm => 16#8E8C#,
Compressed_SRGB_Alpha_BPTC_UNorm => 16#8E8D#,
Compressed_RGB_BPTC_Signed_Float => 16#8E8E#,
Compressed_RGB_BPTC_Unsigned_Float => 16#8E8F#,
Compressed_R11_EAC => 16#9270#,
Compressed_Signed_R11_EAC => 16#9271#,
Compressed_RG11_EAC => 16#9272#,
Compressed_Signed_RG11_EAC => 16#9273#,
Compressed_RGB8_ETC2 => 16#9274#,
Compressed_SRGB8_ETC2 => 16#9275#,
Compressed_RGB8_Punchthrough_Alpha1_ETC2 => 16#9276#,
Compressed_SRGB8_Punchthrough_Alpha1_ETC2 => 16#9277#,
Compressed_RGBA8_ETC2_EAC => 16#9278#,
Compressed_SRGB8_Alpha8_ETC2_EAC => 16#9279#,
-- ASTC (not part of OpenGL core)
Compressed_RGBA_ASTC_4x4_KHR => 16#93B0#,
Compressed_RGBA_ASTC_5x4_KHR => 16#93B1#,
Compressed_RGBA_ASTC_5x5_KHR => 16#93B2#,
Compressed_RGBA_ASTC_6x5_KHR => 16#93B3#,
Compressed_RGBA_ASTC_6x6_KHR => 16#93B4#,
Compressed_RGBA_ASTC_8x5_KHR => 16#93B5#,
Compressed_RGBA_ASTC_8x6_KHR => 16#93B6#,
Compressed_RGBA_ASTC_8x8_KHR => 16#93B7#,
Compressed_RGBA_ASTC_10x5_KHR => 16#93B8#,
Compressed_RGBA_ASTC_10x6_KHR => 16#93B9#,
Compressed_RGBA_ASTC_10x8_KHR => 16#93BA#,
Compressed_RGBA_ASTC_10x10_KHR => 16#93BB#,
Compressed_RGBA_ASTC_12x10_KHR => 16#93BC#,
Compressed_RGBA_ASTC_12x12_KHR => 16#93BD#,
Compressed_SRGB8_ALPHA8_ASTC_4x4_KHR => 16#93D0#,
Compressed_SRGB8_ALPHA8_ASTC_5x4_KHR => 16#93D1#,
Compressed_SRGB8_ALPHA8_ASTC_5x5_KHR => 16#93D2#,
Compressed_SRGB8_ALPHA8_ASTC_6x5_KHR => 16#93D3#,
Compressed_SRGB8_ALPHA8_ASTC_6x6_KHR => 16#93D4#,
Compressed_SRGB8_ALPHA8_ASTC_8x5_KHR => 16#93D5#,
Compressed_SRGB8_ALPHA8_ASTC_8x6_KHR => 16#93D6#,
Compressed_SRGB8_ALPHA8_ASTC_8x8_KHR => 16#93D7#,
Compressed_SRGB8_ALPHA8_ASTC_10x5_KHR => 16#93D8#,
Compressed_SRGB8_ALPHA8_ASTC_10x6_KHR => 16#93D9#,
Compressed_SRGB8_ALPHA8_ASTC_10x8_KHR => 16#93DA#,
Compressed_SRGB8_ALPHA8_ASTC_10x10_KHR => 16#93DB#,
Compressed_SRGB8_ALPHA8_ASTC_12x10_KHR => 16#93DC#,
Compressed_SRGB8_ALPHA8_ASTC_12x12_KHR => 16#93DD#);
for Compressed_Format'Size use Low_Level.Enum'Size;
for Format use (Stencil_Index => 16#1901#,
Depth_Component => 16#1902#,
Red => 16#1903#,
Green => 16#1904#,
Blue => 16#1905#,
RGB => 16#1907#,
RGBA => 16#1908#,
BGR => 16#80E0#,
BGRA => 16#80E1#,
RG => 16#8227#,
RG_Integer => 16#8228#,
Depth_Stencil => 16#84F9#,
Red_Integer => 16#8D94#,
Green_Integer => 16#8D95#,
Blue_Integer => 16#8D96#,
RGB_Integer => 16#8D98#,
RGBA_Integer => 16#8D99#,
BGR_Integer => 16#8D9A#,
BGRA_Integer => 16#8D9B#);
for Format'Size use Low_Level.Enum'Size;
for Data_Type use (Byte => 16#1400#,
Unsigned_Byte => 16#1401#,
Short => 16#1402#,
Unsigned_Short => 16#1403#,
Int => 16#1404#,
Unsigned_Int => 16#1405#,
Float => 16#1406#,
Half_Float => 16#140B#,
Unsigned_Byte_3_3_2 => 16#8032#,
Unsigned_Short_4_4_4_4 => 16#8033#,
Unsigned_Short_5_5_5_1 => 16#8034#,
Unsigned_Int_8_8_8_8 => 16#8035#,
Unsigned_Int_10_10_10_2 => 16#8036#,
Unsigned_Byte_2_3_3_Rev => 16#8362#,
Unsigned_Short_5_6_5 => 16#8363#,
Unsigned_Short_5_6_5_Rev => 16#8364#,
Unsigned_Short_4_4_4_4_Rev => 16#8365#,
Unsigned_Short_1_5_5_5_Rev => 16#8366#,
Unsigned_Int_8_8_8_8_Rev => 16#8367#,
Unsigned_Int_2_10_10_10_Rev => 16#8368#,
Unsigned_Int_24_8 => 16#84FA#,
Unsigned_Int_10F_11F_11F_Rev => 16#8C3B#,
Unsigned_Int_5_9_9_9_Rev => 16#8C3E#,
Float_32_Unsigned_Int_24_8_Rev => 16#8DAD#);
for Data_Type'Size use Low_Level.Enum'Size;
for Channel_Data_Type use (None => 0,
Int_Type => 16#1404#,
Unsigned_Int_Type => 16#1405#,
Float_Type => 16#1406#,
Unsigned_Normalized => 16#8C17#,
Signed_Normalized => 16#8F9C#);
for Channel_Data_Type'Size use Low_Level.Enum'Size;
for Alignment use (Bytes => 1,
Even_Bytes => 2,
Words => 4,
Double_Words => 8);
for Alignment'Size use Types.Int'Size;
end GL.Pixels;
|
gfx/pokemon/nincada/anim.asm | Ebernacher90/pokecrystal-allworld | 0 | 24388 | frame 1, 08
frame 2, 08
frame 1, 08
frame 2, 06
frame 1, 06
frame 3, 08
frame 0, 08
frame 3, 08
endanim
|
src/wi2wic-rest.adb | stcarrez/wi2wic | 2 | 29607 | <gh_stars>1-10
-----------------------------------------------------------------------
-- wi2wic-rest -- REST entry points
-- Copyright (C) 2020 <NAME>
-- Written by <NAME> (<EMAIL>)
--
-- Licensed under the Apache License, Version 2.0 (the "License");
-- you may not use this file except in compliance with the License.
-- You may obtain a copy of the License at
--
-- http://www.apache.org/licenses/LICENSE-2.0
--
-- Unless required by applicable law or agreed to in writing, software
-- distributed under the License is distributed on an "AS IS" BASIS,
-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-- See the License for the specific language governing permissions and
-- limitations under the License.
-----------------------------------------------------------------------
with Wiki.Strings;
with Wiki.Streams;
with Wiki.Parsers;
with Wiki.Filters.Html;
with Wiki.Render.Html;
with Wiki.Render.Wiki;
with Wiki.Streams.Html.Stream;
with Util.Http.Clients;
with Util.Strings;
with Servlet.Rest.Operation;
package body Wi2wic.Rest is
use type Wiki.Wiki_Syntax;
URI_Prefix : constant String := "/v1";
package API_Import is
new Servlet.Rest.Operation (Handler => Import'Access,
Method => Servlet.Rest.POST,
URI => URI_Prefix & "/import/{target}");
package API_Convert is
new Servlet.Rest.Operation (Handler => Convert'Access,
Method => Servlet.Rest.POST,
URI => URI_Prefix & "/converter/{format}/{target}");
package API_Render is
new Servlet.Rest.Operation (Handler => Render'Access,
Method => Servlet.Rest.POST,
URI => URI_Prefix & "/render/{format}");
Invalid_Format : exception;
function Get_Syntax (Name : in String) return Wiki.Wiki_Syntax is
begin
if Name = "markdown" then
return Wiki.SYNTAX_MARKDOWN;
elsif Name = "dotclear" then
return Wiki.SYNTAX_DOTCLEAR;
elsif Name = "creoler" then
return Wiki.SYNTAX_CREOLE;
elsif Name = "mediawiki" then
return Wiki.SYNTAX_MEDIA_WIKI;
elsif Name = "html" then
return Wiki.SYNTAX_HTML;
else
raise Invalid_Format;
end if;
end Get_Syntax;
procedure Import_Doc (Doc : in out Wiki.Documents.Document;
Syntax : in Wiki.Wiki_Syntax;
Stream : in out Servlet.Streams.Input_Stream'Class) is
type Input_Stream is new Wiki.Streams.Input_Stream with null record;
-- Read one character from the input stream and return False to the <tt>Eof</tt> indicator.
-- When there is no character to read, return True in the <tt>Eof</tt> indicator.
overriding
procedure Read (Input : in out Input_Stream;
Char : out Wiki.Strings.WChar;
Eof : out Boolean);
overriding
procedure Read (Input : in out Input_Stream;
Char : out Wiki.Strings.WChar;
Eof : out Boolean) is
begin
Stream.Read (Char);
Eof := Stream.Is_Eof;
exception
when others =>
Eof := True;
end Read;
Html_Filter : aliased Wiki.Filters.Html.Html_Filter_Type;
In_Stream : aliased Input_Stream;
Engine : Wiki.Parsers.Parser;
begin
Html_Filter.Hide (Wiki.FOOTER_TAG);
Html_Filter.Hide (Wiki.HEAD_TAG);
Html_Filter.Hide (Wiki.HEADER_TAG);
Html_Filter.Hide (Wiki.ADDRESS_TAG);
Html_Filter.Hide (Wiki.IFRAME_TAG);
Engine.Set_Syntax (Syntax);
Engine.Add_Filter (Html_Filter'Unchecked_Access);
Engine.Parse (In_Stream'Unchecked_Access, Doc);
end Import_Doc;
procedure Render_Doc (Doc : in out Wiki.Documents.Document;
Syntax : in Wiki.Wiki_Syntax;
Output : in out Servlet.Rest.Output_Stream'Class) is
type Output_Stream is limited new Wiki.Streams.Output_Stream with null record;
-- Write the string to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Content : in Wiki.Strings.WString);
-- Write a single character to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Char : in Wiki.Strings.WChar);
-- Write the string to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Content : in Wiki.Strings.WString) is
begin
Output.Write_Wide (Content);
end Write;
-- Write a single character to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Char : in Wiki.Strings.WChar) is
begin
Output.Write_Wide (Char);
end Write;
Out_Stream : aliased Output_Stream;
Renderer : Wiki.Render.Wiki.Wiki_Renderer;
begin
Renderer.Set_Output_Stream (Out_Stream'Unchecked_Access, Syntax);
Renderer.Render (Doc);
end Render_Doc;
procedure Render_Html (Doc : in out Wiki.Documents.Document;
Output : in out Servlet.Rest.Output_Stream'Class) is
type Output_Stream is limited new Wiki.Streams.Output_Stream with null record;
-- Write the string to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Content : in Wiki.Strings.WString);
-- Write a single character to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Char : in Wiki.Strings.WChar);
-- Write the string to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Content : in Wiki.Strings.WString) is
begin
Output.Write_Wide (Content);
end Write;
-- Write a single character to the output stream.
overriding
procedure Write (Stream : in out Output_Stream;
Char : in Wiki.Strings.WChar) is
begin
Output.Write_Wide (Char);
end Write;
package Html_Stream is
new Wiki.Streams.Html.Stream (Output_Stream);
Out_Stream : aliased Html_Stream.Html_Output_Stream;
Renderer : Wiki.Render.Html.Html_Renderer;
begin
Renderer.Set_Render_TOC (True);
Renderer.Set_Output_Stream (Out_Stream'Unchecked_Access);
Renderer.Render (Doc);
end Render_Html;
-- ------------------------------
-- Import an HTML content by getting the HTML content from a URL
-- and convert to the target wiki syntax.
-- ------------------------------
procedure Import (Req : in out Servlet.Requests.Request'Class;
Reply : in out Servlet.Responses.Response'Class;
Stream : in out Servlet.Rest.Output_Stream'Class) is
Doc : Wiki.Documents.Document;
Target : constant String := Req.Get_Path_Parameter (1);
URL : constant String := Req.Get_Parameter ("url");
Syntax : Wiki.Wiki_Syntax;
Download : Util.Http.Clients.Client;
Content : Util.Http.Clients.Response;
begin
Syntax := Get_Syntax (Target);
if not Util.Strings.Starts_With (URL, "http://")
and not Util.Strings.Starts_With (URL, "https://")
then
Reply.Set_Status (Util.Http.SC_BAD_REQUEST);
return;
end if;
Download.Add_Header ("X-Requested-By", "wi2wic");
Download.Set_Timeout (5.0);
begin
Download.Get (URL, Content);
exception
when Util.Http.Clients.Connection_Error =>
Reply.Set_Status (Util.Http.SC_REQUEST_TIMEOUT);
return;
when others =>
Reply.Set_Status (Util.Http.SC_EXPECTATION_FAILED);
return;
end;
declare
Html_Filter : aliased Wiki.Filters.Html.Html_Filter_Type;
Engine : Wiki.Parsers.Parser;
Data : constant String := Content.Get_Body;
begin
Html_Filter.Hide (Wiki.FOOTER_TAG);
Html_Filter.Hide (Wiki.HEAD_TAG);
Html_Filter.Hide (Wiki.HEADER_TAG);
Html_Filter.Hide (Wiki.ADDRESS_TAG);
Html_Filter.Hide (Wiki.IFRAME_TAG);
Engine.Set_Syntax (Wiki.SYNTAX_HTML);
Engine.Add_Filter (Html_Filter'Unchecked_Access);
Engine.Parse (Data, Doc);
end;
Render_Doc (Doc, Syntax, Stream);
exception
when Invalid_Format =>
Reply.Set_Status (Util.Http.SC_NOT_FOUND);
end Import;
-- ------------------------------
-- Convert a Wiki text from one format to another.
-- ------------------------------
procedure Convert (Req : in out Servlet.Requests.Request'Class;
Reply : in out Servlet.Responses.Response'Class;
Stream : in out Servlet.Rest.Output_Stream'Class) is
Doc : Wiki.Documents.Document;
Format : constant String := Req.Get_Path_Parameter (1);
Target : constant String := Req.Get_Path_Parameter (2);
begin
Import_Doc (Doc, Get_Syntax (Format), Req.Get_Input_Stream.all);
Render_Doc (Doc, Get_Syntax (Target), Stream);
exception
when Invalid_Format =>
Reply.Set_Status (Util.Http.SC_NOT_FOUND);
end Convert;
-- ------------------------------
-- Render the Wiki content in HTML.
-- ------------------------------
procedure Render (Req : in out Servlet.Requests.Request'Class;
Reply : in out Servlet.Responses.Response'Class;
Stream : in out Servlet.Rest.Output_Stream'Class) is
Doc : Wiki.Documents.Document;
Format : constant String := Req.Get_Path_Parameter (1);
begin
Import_Doc (Doc, Get_Syntax (Format), Req.Get_Input_Stream.all);
Render_Html (Doc, Stream);
exception
when Invalid_Format =>
Reply.Set_Status (Util.Http.SC_NOT_FOUND);
end Render;
procedure Register (Server : in out Servlet.Core.Servlet_Registry'Class) is
begin
Servlet.Rest.Register (Server, API_Convert.Definition);
Servlet.Rest.Register (Server, API_Render.Definition);
Servlet.Rest.Register (Server, API_Import.Definition);
end Register;
end Wi2wic.Rest;
|
programs/oeis/132/A132314.asm | neoneye/loda | 22 | 165345 | ; A132314: a(n) = n*2^floor((n+1)/2).
; 0,2,4,12,16,40,48,112,128,288,320,704,768,1664,1792,3840,4096,8704,9216,19456,20480,43008,45056,94208,98304,204800,212992,442368,458752,950272,983040,2031616,2097152,4325376,4456448,9175040,9437184,19398656,19922944,40894464,41943040,85983232,88080384,180355072,184549376,377487360,385875968,788529152,805306368,1644167168,1677721600,3422552064,3489660928,7113539584,7247757312,14763950080,15032385536,30601641984,31138512896,63350767616,64424509440,130996502528,133143986176,270582939648,274877906944,558345748480,566935683072,1151051235328,1168231104512,2370821947392,2405181685760,4879082848256,4947802324992,10033043603456,10170482556928,20615843020800,20890720927744,42331197669376,42880953483264,86861418594304,87960930222080,178120883699712,180319906955264,365037860421632,369435906932736,747667906887680,756463999909888,1530520185864192,1548112371908608,3131409115906048,3166593487994880,6403555720167424,6473924464345088,13088586417045504,13229323905400832,26740122787512320,27021597764222976,54606145481867264,55169095435288576,111464090777419776
mov $1,$0
sub $1,1
lpb $1
mul $0,2
sub $1,2
lpe
mul $0,2
|
lab4/es4.asm | neskov7/AssemblyProgramsCE | 0 | 26673 | <filename>lab4/es4.asm
DIM EQU 8
.model small
.stack
.data
matrice db 0, 4 , 0 , 0, 0 , 0 , 0 , 60
db 0, 5 , 0 , 0, 11, 0 , 0 , 0
db 0, 5 , 7 , 0, 0 , 10, 0 , 0
db 0, 0 , 0 , 9, 0 , 0 , 49, 0
db 0, 0 , 10, 0, 0 , 0 , 0 , 0
db 0, 10, 3 , 9, 0 , 0 , 12, 0
db 0, 0 , 58, 0, 0 , 17, 0 , 0
db 0, 1 , 0 , 0, 3 , 0 , 0 , 0
somme db DIM*DIM (0)
coordx dw ?
coordy dw ?
.code
.startup
mov di,0
mov bx,0
mov cx,DIM
mov dx,0
cicloy:
mov di,0
ciclox:
mov ax,0
cmp bx,0
jz skipNord
mov al,matrice[bx-DIM][di]
add ah,al
skipNord:
cmp bx,DIM-1
jz skipSud
mov al,matrice[bx+DIM][di]
add ah,al
skipSud:
cmp di,0
jz skipOvest
mov al,matrice[bx][di-1]
add ah,al
skipOvest:
cmp di,DIM-1
jz skipEst
mov al,matrice[bx][di+1]
add ah,al
skipEst:
mov somme[bx][di],ah
;check del max
cmp ah,dl
jg aggiornaMax
rp:
inc di
cmp di,DIM
jnz ciclox
add bx,DIM
loop cicloy
jmp fin
aggiornaMax:
mov dl,ah
mov coordx,di
mov coordy,bx
jmp rp
fin:
.exit
end |
gfx/pokemon/poochyena/anim_idle.asm | Ebernacher90/pokecrystal-allworld | 0 | 21269 | <filename>gfx/pokemon/poochyena/anim_idle.asm
setrepeat 2
frame 5, 06
frame 0, 06
dorepeat 1
endanim
|
oeis/092/A092724.asm | neoneye/loda-programs | 11 | 167045 | ; A092724: Disk degeneracies for brane III in the O(K)->P^1 x P^1 geometry.
; 0,0,0,0,0,0,0,-264,-4224,-35640
sub $3,$0
lpb $0
sub $0,7
mov $2,6
sub $2,$3
bin $2,$0
lpe
mul $2,$3
mov $0,$2
div $0,7
mul $0,264
|
tests/cl_test-hello_world.adb | flyx/OpenCLAda | 8 | 5030 | --------------------------------------------------------------------------------
-- Copyright (c) 2013, <NAME> <<EMAIL>>
--
-- Permission to use, copy, modify, and/or distribute this software for any
-- purpose with or without fee is hereby granted, provided that the above
-- copyright notice and this permission notice appear in all copies.
--
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--------------------------------------------------------------------------------
with Ada.Text_IO;
with CL.Platforms;
with CL.Contexts;
with CL.Programs;
with CL.Memory.Buffers;
with CL.Kernels;
with CL.Command_Queues;
with CL.Queueing;
with CL.Queueing.Memory_Objects;
with CL.Events;
with CL_Test.Helpers;
procedure CL_Test.Hello_World is
package IO renames Ada.Text_IO;
type Aliased_String is array (Integer range <>) of aliased Character;
function String_Buffer is
new CL.Memory.Buffers.Constructors.Create_From_Source (Element => Character,
Element_List => Aliased_String);
package String_Objects is
new CL.Queueing.Memory_Objects (Element => Character,
Element_List => Aliased_String);
Platform : CL.Platforms.Platform;
Device : CL.Platforms.Device;
Device_List : CL.Platforms.Device_List (1 .. 1);
Context : CL.Contexts.Context;
Buffer : CL.Memory.Buffers.Buffer;
Program : CL.Programs.Program;
Kernel : CL.Kernels.Kernel;
Queue : CL.Command_Queues.Queue;
Event : CL.Events.Event;
Hello_World : constant String := "Hello world!";
Output : aliased constant Aliased_String := (Hello_World'Range => <>);
Kernel_File : IO.File_Type;
Global_Work_Size : aliased CL.Size_List := (1 => Hello_World'Length);
Local_Work_Size : aliased CL.Size_List := (1 => 1);
begin
IO.Put_Line ("Gathering platform and devices");
Platform := CL.Platforms.List (1);
Device := Platform.Devices (CL.Platforms.Device_Kind_All) (Platform.Devices (CL.Platforms.Device_Kind_All)'First);
Device_List := (1 => Device);
IO.Put_Line ("Creating context");
Context := CL.Contexts.Constructors.Create_For_Devices (Platform, (1 => Device));
IO.Put_Line ("Creating buffer");
Buffer := String_Buffer (Context, CL.Memory.Write_Only, Output);
IO.Put_Line ("Compiling kernel source");
IO.Open (Kernel_File, IO.In_File, "../tests/hello-kernel.cl");
declare
Kernel_Source : constant String := CL_Test.Helpers.Read_File (Kernel_File);
begin
IO.Close (Kernel_File);
Program := CL.Programs.Constructors.Create_From_Source
(Context, Kernel_Source);
end;
Program.Build (Device_List, "", null);
IO.Put_Line ("Creating kernel");
Kernel := CL.Kernels.Constructors.Create (Program, "hello");
IO.Put_Line ("Setting kernel argument");
CL.Kernels.Set_Kernel_Argument_Object (Kernel, 0, Buffer);
IO.Put_Line ("Creating queue");
Queue := CL.Command_Queues.Constructors.Create
(Context, Device, CL.Platforms.CQ_Property_Vector'(Out_Of_Order_Exec_Mode_Enable => False,
Profiling_Enable => False));
IO.Put_Line ("Queueing kernel");
Event := CL.Queueing.Execute_Kernel (Queue, Kernel, 1, Global_Work_Size'Access,
Local_Work_Size'Access, null);
Event.Wait_For;
IO.Put_Line ("Retrieving result");
String_Objects.Read_Buffer (Queue, Buffer, True, 0, Output, Event);
Event.Wait_For;
IO.Put_Line (String (Output));
end CL_Test.Hello_World;
|
src/STLCSF/Semantics.agda | metaborg/mj.agda | 10 | 5381 | open import Agda.Primitive
open import Data.Unit
open import Data.Nat hiding (_⊔_ ; _^_)
open import Data.Integer hiding (_⊔_)
open import Data.List
open import Data.List.Relation.Unary.Any
open import Data.List.Relation.Unary.All as All
open import Data.List.Membership.Propositional
open import Data.Product
open import Data.Maybe hiding (_>>=_)
open import Data.List.Prefix
open import Data.List.Properties.Extra
open import Data.List.All.Properties.Extra
open import Function
open import Relation.Binary.PropositionalEquality hiding ([_])
open ≡-Reasoning
open import Common.Weakening
-- This file contains the definitional interpreter for STLC using
-- scopes and frames, described in Section 4 of the paper.
-- The scopes-and-frames library assumes that we are given a
-- particular scope graph, with `k` scopes. The following module is
-- parameterized by a `k` representing the number of scopes that a
-- particular object language program has.
module STLCSF.Semantics (k : ℕ) where
-----------
-- TYPES --
-----------
data Ty : Set where
unit : Ty
_⇒_ : (a b : Ty) → Ty
int : Ty
-- The library is loaded and passed two arguments:
--
-- * `k` is the size of the scope graph for an object program
--
-- * `Ty` is the type of declarations in the scope graph
open import ScopesFrames.ScopesFrames k Ty
-- Our interpreter is parameterized by a scope graph, via the module
-- below.
module Syntax (g : Graph) where
-- We load all the scope graph definitions in the scope graph
-- library, by passing the object scope graph `g` as module
-- parameter:
open UsesGraph g
------------
-- SYNTAX --
------------
-- We can now define our well-typed syntax as described in the paper
-- Section 4.2:
data Expr (s : Scope) : Ty → Set where
unit : Expr s unit
var : ∀ {t} → (s ↦ t) → Expr s t
ƛ : ∀ {s' a b} → ⦃ shape : g s' ≡ ( [ a ] , [ s ] ) ⦄ → Expr s' b → Expr s (a ⇒ b)
_·_ : ∀ {a b} → Expr s (a ⇒ b) → Expr s a → Expr s b
num : ℤ → Expr s int
iop : (ℤ → ℤ → ℤ) → (l r : Expr s int) → Expr s int
------------
-- VALUES --
------------
-- We can also define well-typed values as described in the paper
-- Section 4.4:
data Val : Ty → (Σ : HeapTy) → Set where
unit : ∀ {Σ} → Val unit Σ
⟨_,_⟩ : ∀ {Σ s s' a b}⦃ shape : g s' ≡ ( [ a ] , [ s ] ) ⦄ →
Expr s' b → Frame s Σ → Val (a ⇒ b) Σ
num : ∀ {Σ} → ℤ → Val int Σ
val-weaken : ∀ {t Σ Σ'} → Σ ⊑ Σ' → Val t Σ → Val t Σ'
val-weaken ext ⟨ e , f ⟩ = ⟨ e , wk ext f ⟩
val-weaken ext unit = unit
val-weaken ext (num z) = num z
-- We can now load the frames definitions of the scopes-and-frames
-- library. As described in Section 4.3 of the paper, our notion of
-- frame assumes a notion of weakenable value, to be passed as
-- module arguments to `UsesVal`:
open UsesVal Val val-weaken renaming (getFrame to getFrame')
-- We rename `getFrame` from the scopes-and-frames library so that
-- we can use `getFrame` as the name of the monadic operation which
-- returns the "current frame pointer" below.
-----------
-- MONAD --
-----------
-- These definitions correspond to Section 4.4.
M : (s : Scope) → (HeapTy → Set) → HeapTy → Set
M s p Σ = Frame s Σ → Heap Σ → Maybe (∃ λ Σ' → (Heap Σ' × p Σ' × Σ ⊑ Σ'))
_>>=_ : ∀ {s Σ}{p q : List Scope → Set} →
M s p Σ → (∀ {Σ'} → p Σ' → M s q Σ') → M s q Σ
(a >>= b) f h
with (a f h)
... | nothing = nothing
... | just (Σ , h' , v , ext)
with (b v (wk ext f) h')
... | nothing = nothing
... | just (Σ' , h'' , v' , ext') = just (Σ' , h'' , v' , ext ⊚ ext')
return : ∀ {s Σ}{p : List Scope → Set} → p Σ → M s p Σ
return v f h = just (_ , h , v , ⊑-refl)
getFrame : ∀ {s Σ} → M s (Frame s) Σ
getFrame f = return f f
usingFrame : ∀ {s s' Σ}{p : List Scope → Set} → Frame s Σ → M s p Σ → M s' p Σ
usingFrame f a _ = a f
timeout : ∀ {s Σ}{p : List Scope → Set} → M s p Σ
timeout _ _ = nothing
init : ∀ {Σ s' ds es}(s : Scope)⦃ shape : g s ≡ (ds , es) ⦄ →
Slots ds Σ → Links es Σ → M s' (Frame s) Σ
init {Σ} s slots links _ h
with (initFrame s slots links h)
... | (f' , h') = just (_ , h' , f' , ∷ʳ-⊒ s Σ)
getv : ∀ {s t Σ} → (s ↦ t) → M s (Val t) Σ
getv p f h = return (getVal p f h) f h
_^_ : ∀ {Σ Γ}{p q : List Scope → Set} → ⦃ w : Weakenable q ⦄ →
M Γ p Σ → q Σ → M Γ (p ⊗ q) Σ
(a ^ x) f h
with (a f h)
... | nothing = nothing
... | just (Σ , h' , v , ext) = just (Σ , h' , (v , wk ext x) , ext)
sₑ : ∀ {s t} → Expr s t → Scope
sₑ {s} _ = s
eval : ℕ → ∀ {s t Σ} → Expr s t → M s (Val t) Σ
eval zero _ =
timeout
eval (suc k) unit =
return unit
eval (suc k) (var x) =
getv x
eval (suc k) (ƛ e) =
getFrame >>= λ f →
return ⟨ e , f ⟩
eval (suc k) (l · r) =
eval k l >>= λ{ ⟨ e , f ⟩ →
(eval k r ^ f) >>= λ{ (v , f) →
init (sₑ e) (v ∷ []) (f ∷ []) >>= λ f' →
usingFrame f' (eval k e) }}
eval (suc k) (num z) =
return (num z)
eval (suc k) (iop f l r) =
eval k l >>= λ{ (num z₁) →
eval k r >>= λ{ (num z₂) →
return (num (f z₁ z₂)) }}
|
sharding-parser/src/main/antlr4/autogen/MySQLStatement.g4 | ns7381/MyDatabase | 1 | 3261 |
grammar MySQLStatement;
import Symbol, Comments, DMLStatement, DDLStatement, DALStatement;
execute
: (use
| select
| insert
| update
| delete
| createTable
| alterTable
| truncateTable
| dropTable
| showTables
| createIndex
| dropIndex
| createDatabase
| showDatabases
) SEMI_?
;
|
experiments/test-suite/mutation-based/20/3/sll.als | kaiyuanw/AlloyFLCore | 1 | 2595 | pred test15 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0 + Node2->Node2
Acyclic[List0]
}}
}
run test15 for 3 expect 0
pred test2 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List1->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0
}}
}
run test2 for 3 expect 1
pred test14 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node1->Node0 + Node2->Node2
Acyclic[List1]
}}
}
run test14 for 3 expect 1
pred test6 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0
}}
}
run test6 for 3 expect 1
|
src/fot/FOTC/Data/Nat/UnaryNumbers/TotalityI.agda | asr/fotc | 11 | 1383 | ------------------------------------------------------------------------------
-- The unary numbers are FOTC total natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOTC.Data.Nat.UnaryNumbers.TotalityI where
open import FOTC.Base
open import FOTC.Data.Nat.Type
open import FOTC.Data.Nat.UnaryNumbers
------------------------------------------------------------------------------
0-N : N 0'
0-N = nzero
1-N : N 1'
1-N = nsucc 0-N
2-N : N 2'
2-N = nsucc 1-N
|
libsrc/_DEVELOPMENT/adt/wv_priority_queue/c/sdcc_iy/wv_priority_queue_pop_fastcall.asm | jpoikela/z88dk | 640 | 92034 | <gh_stars>100-1000
; void *wv_priority_queue_pop_fastcall(wv_priority_queue_t *q)
SECTION code_clib
SECTION code_adt_wv_priority_queue
PUBLIC _wv_priority_queue_pop_fastcall
EXTERN asm_wv_priority_queue_pop
defc _wv_priority_queue_pop_fastcall = asm_wv_priority_queue_pop
|
test/Succeed/Issue2053.agda | cruhland/agda | 1,989 | 12100 | <filename>test/Succeed/Issue2053.agda
data N : Set where
suc : N → N
data Val : N → Set where
valSuc : ∀ n → Val (suc n)
record R : Set where
constructor wrap
field unwrap : N
data W (ft : R) : Set where
immed : (v : Val (R.unwrap ft)) → W ft
test : (fa : R) → W fa → R
test fa (immed (valSuc a)) = fa
postulate
Evaluate : ∀ (ft : R) (P : (w : W ft) → Set) → Set
test₂ : ∀ (fa : R) → Set
test₂ fa = Evaluate fa testw
where
testw : W fa → Set
testw (immed (valSuc a)) = W fa
|
programs/oeis/213/A213723.asm | neoneye/loda | 22 | 170725 | <gh_stars>10-100
; A213723: a(n) = smallest natural number x such that x=n+A000120(x), otherwise zero.
; 0,2,0,4,6,0,0,8,10,0,12,14,0,0,0,16,18,0,20,22,0,0,24,26,0,28,30,0,0,0,0,32,34,0,36,38,0,0,40,42,0,44,46,0,0,0,48,50,0,52,54,0,0,56,58,0,60,62,0,0,0,0,0,64,66,0,68,70,0,0,72,74,0,76,78,0,0,0,80,82,0,84,86,0,0,88,90,0,92,94,0,0,0,0,96,98,0,100,102,0
seq $0,213724 ; Largest natural number x such that x=n+A000120(x), or zero if no such number exists.
trn $0,1
|
mc-sema/validator/x86/tests/XADD32rm.asm | randolphwong/mcsema | 2 | 245108 | BITS 32
;TEST_FILE_META_BEGIN
;TEST_TYPE=TEST_F
;TEST_IGNOREFLAGS=
;TEST_FILE_META_END
; XADD32rm
;TEST_BEGIN_RECORDING
lea edi, [esp-0x4]
mov DWORD [edi], 0xabcd4321
mov eax, 0x56781234
xadd [edi], eax
mov edx, [edi]
mov edi, 0x0
;TEST_END_RECORDING
|
Fields/Fields.agda | Smaug123/agdaproofs | 4 | 7520 | <reponame>Smaug123/agdaproofs
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Definition
open import Rings.Definition
open import Setoids.Setoids
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Fields.Fields where
record Field {m n : _} {A : Set m} {S : Setoid {m} {n} A} {_+_ : A → A → A} {_*_ : A → A → A} (R : Ring S _+_ _*_) : Set (lsuc m ⊔ n) where
open Ring R
open Group additiveGroup
open Setoid S
field
allInvertible : (a : A) → ((a ∼ Group.0G (Ring.additiveGroup R)) → False) → Sg A (λ t → t * a ∼ 1R)
nontrivial : (0R ∼ 1R) → False
0F : A
0F = Ring.0R R
record Field' {m n : _} : Set (lsuc m ⊔ lsuc n) where
field
A : Set m
S : Setoid {m} {n} A
_+_ : A → A → A
_*_ : A → A → A
R : Ring S _+_ _*_
isField : Field R
encapsulateField : {m n : _} {A : Set m} {S : Setoid {m} {n} A} {_+_ : A → A → A} {_*_ : A → A → A} {R : Ring S _+_ _*_} (F : Field R) → Field'
encapsulateField {A = A} {S = S} {_+_} {_*_} {R} F = record { A = A ; S = S ; _+_ = _+_ ; _*_ = _*_ ; R = R ; isField = F }
{-
record OrderedField {n} {A : Set n} {R : Ring A} (F : Field R) : Set (lsuc n) where
open Field F
field
ord : TotalOrder A
open TotalOrder ord
open Ring R
field
productPos : {a b : A} → (0R < a) → (0R < b) → (0R < (a * b))
orderRespectsAddition : {a b c : A} → (a < b) → (a + c) < (b + c)
-}
|
oeis/156/A156872.asm | neoneye/loda-programs | 11 | 80443 | ; A156872: Period 12: 1,3,-1,3,1,0,-1,-3,1,-3,-1,0 repeated.
; Submitted by <NAME>
; 1,3,-1,3,1,0,-1,-3,1,-3,-1,0,1,3,-1,3,1,0,-1,-3,1,-3,-1,0,1,3,-1,3,1,0,-1,-3,1,-3,-1,0,1,3,-1,3,1,0,-1,-3,1,-3,-1,0,1,3,-1,3,1,0,-1,-3,1,-3,-1,0
mul $0,2
add $0,1
mov $3,1
lpb $0
sub $0,1
sub $1,$3
mov $2,$3
mul $3,20
mod $3,9
add $3,$1
mov $1,$2
lpe
mov $0,$3
|
programs/oeis/332/A332190.asm | neoneye/loda | 22 | 243391 | <reponame>neoneye/loda<filename>programs/oeis/332/A332190.asm
; A332190: a(n) = 10^(2n+1) - 1 - 9*10^n.
; 0,909,99099,9990999,999909999,99999099999,9999990999999,999999909999999,99999999099999999,9999999990999999999,999999999909999999999,99999999999099999999999,9999999999990999999999999,999999999999909999999999999,99999999999999099999999999999,9999999999999990999999999999999
add $0,1
mov $1,10
pow $1,$0
sub $1,4
bin $1,2
sub $1,15
div $1,5
mov $0,$1
|
filtros/monocromatizar_uno_asm.asm | partu18/edge_detection_algorithm_SIMD | 0 | 6858 | ; void monocromatizar_uno_asm (
; unsigned char *src,
; unsigned char *dst,
; int h,
; int w, en pixels
; int src_row_size, en bytes
; int dst_row_size
; );
section .data
mask: DQ 0x00000000FFFFFFFF
maskPrimeroCuarto: DW 0xFFFF, 0x0000, 0x0000, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000
maskPrimerosDos: DW 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
section .text
global monocromatizar_uno_asm
monocromatizar_uno_asm:
; rdi --> *src/ puntero a src
; rsi --> *dst/ dst
; rdx --> h/ cantidad de filas
; rcx --> w/ columnas
; r8 --> src_row size
; r9 --> dst_row_size
PUSH rbp ; Alinea
MOV rbp, rsp
PUSH r13 ; salva r13 Alinea
PUSH r14 ; salva r14 Desalinea
MOV rax, [mask] ; pone en rax lo que se usa como máscara
AND rdx, rax ; máscara a rdx para dejar la parte baja únicamente
AND rcx, rax ; máscara a rcx para dejar la parte baja únicamente
AND r8, rax ; máscara a r8 para dejar la parte baja únicamente
AND r9, rax ; máscara a r9 para dejar la parte baja únicamente
XOR r11,r11;
XOR rax,rax;
cicloPorFilaMU:
CMP rdx, 0; para ver si termine de ciclar todas las filas
JE salirMU
MOV r11, rcx; muevo al cantidad de columnas a r11
MOV r14, rdi; hago el iterador de columnas de srca
MOV r13, rsi; hago el iterador de columnas de dst
cicloPorColumnaMU:
CMP r11, 0; comparo para ver si ya miré todas las columnas
JE cambiarDeFilaMU
CMP r11, 16; comparo para ver si estoy cerca del w
JL redimensionarMU
;Primera tanda
MOVDQU xmm0, [r14] ; pone en xmm0 la primera tirada de 16 bytes (|BGR, BGR, BGR, BGR|, BGR, B)
PXOR xmm15, xmm15 ; limpia xmm15
MOVDQU xmm1, xmm0 ; copia al xmm1 lo de memoria
MOVDQU xmm2, xmm0 ; copia al xmm2 lo de memoria
PUNPCKLBW xmm1, xmm15 ; pasa al xmm1 en tamaño word los primeros (|BGR, BGR|, BG)
PSLLDQ xmm2, 2 ; mueve dos bytes a derecha para que queden como parte baja los dos pixeles segundos o sea (00, BGR, BGR, |BGR, BGR|, BG)
PUNPCKHBW xmm2, xmm15 ; pasa al xmm1 en tamaño word los segundos (|BGR, BGR|, BG)
; cálculo HIGH
MOVDQU xmm3, xmm1 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm1 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm1, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
; cálculo LOW
MOVDQU xmm3, xmm2 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm2 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm2, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
;máscaras
MOVDQU xmm15, [maskPrimeroCuarto] ; pone en xmm15 la máscara para filtrar primero y cuarto
PAND xmm1, xmm15 ; aplica la máscara
PAND xmm2, xmm15 ; aplica la máscara
MOVDQU xmm14, xmm1 ; pone en xmm14 a xmm1
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm1, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm1, xmm15 ; deja los primeros dos
MOVDQU xmm14, xmm2 ; pone en xmm14 a xmm2
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm2, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm2, xmm15 ; deja los primeros dos
PSLLDQ xmm2, 4 ; deja los dos segundo en las posiciones 3 y 4
PADDW xmm1, xmm2 ; deja en xmm1 los datos (1, 2, 3, 4, 0, 0, 0, 0)
MOVDQU xmm10, xmm1 ; deja en xmm10 este registro para usarlo después
; pasa a los siguientes 4 píxeles
LEA r14, [r14+12] ; aumenta 12 bytes para pasar a los siguientes
;Segunda tanda
MOVDQU xmm0, [r14] ; pone en xmm0 la primera tirada de 16 bytes (|BGR, BGR, BGR, BGR|, BGR, B)
PXOR xmm15, xmm15 ; limpia xmm15
MOVDQU xmm1, xmm0 ; copia al xmm1 lo de memoria
MOVDQU xmm2, xmm0 ; copia al xmm2 lo de memoria
PUNPCKLBW xmm1, xmm15 ; pasa al xmm1 en tamaño word los primeros (|BGR, BGR|, BG)
PSLLDQ xmm2, 2 ; mueve dos bytes a derecha para que queden como parte baja los dos pixeles segundos o sea (00, BGR, BGR, |BGR, BGR|, BG)
PUNPCKHBW xmm2, xmm15 ; pasa al xmm1 en tamaño word los segundos (|BGR, BGR|, BG)
; cálculo HIGH
MOVDQU xmm3, xmm1 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm1 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm1, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
; cálculo <LOW
MOVDQU xmm3, xmm2 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm2 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm2, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
;máscaras
MOVDQU xmm15, [maskPrimeroCuarto] ; pone en xmm15 la máscara para filtrar primero y cuarto
PAND xmm1, xmm15 ; aplica la máscara
PAND xmm2, xmm15 ; aplica la máscara
MOVDQU xmm14, xmm1 ; pone en xmm14 a xmm1
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm1, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm1, xmm15 ; deja los primeros dos
MOVDQU xmm14, xmm2 ; pone en xmm14 a xmm2
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm2, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm2, xmm15 ; deja los primeros dos
PSLLDQ xmm2, 4 ; deja los dos segundo en las posiciones 3 y 4
PADDW xmm1, xmm2 ; deja en xmm1 los datos (5, 6, 7, 8, 0, 0, 0, 0)
PSLLDQ xmm1, 8 ; pasa a derecha 8 bytes (words) para tener (0, 0, 0, 0, 5, 6, 7, 8)
PADDW xmm10, xmm1 ; deja en xmm10 (1, 2, 3, 4, 5, 6, 7, 8)
; pasa a los siguientes 4 píxeles
LEA r14, [r14+12] ; aumenta 12 bytes para pasar a los siguientes
;Tercera tanda
MOVDQU xmm0, [r14] ; pone en xmm0 la primera tirada de 16 bytes (|BGR, BGR, BGR, BGR|, BGR, B)
PXOR xmm15, xmm15 ; limpia xmm15
MOVDQU xmm1, xmm0 ; copia al xmm1 lo de memoria
MOVDQU xmm2, xmm0 ; copia al xmm2 lo de memoria
PUNPCKLBW xmm1, xmm15 ; pasa al xmm1 en tamaño word los primeros (|BGR, BGR|, BG)
PSLLDQ xmm2, 2 ; mueve dos bytes a derecha para que queden como parte baja los dos pixeles segundos o sea (00, BGR, BGR, |BGR, BGR|, BG)
PUNPCKHBW xmm2, xmm15 ; pasa al xmm1 en tamaño word los segundos (|BGR, BGR|, BG)
; cálculo HIGH
MOVDQU xmm3, xmm1 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm1 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm1, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
; cálculo LOW
MOVDQU xmm3, xmm2 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm2 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm2, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
;máscaras
MOVDQU xmm15, [maskPrimeroCuarto] ; pone en xmm15 la máscara para filtrar primero y cuarto
PAND xmm1, xmm15 ; aplica la máscara
PAND xmm2, xmm15 ; aplica la máscara
MOVDQU xmm14, xmm1 ; pone en xmm14 a xmm1
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm1, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm1, xmm15 ; deja los primeros dos
MOVDQU xmm14, xmm2 ; pone en xmm14 a xmm2
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm2, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm2, xmm15 ; deja los primeros dos
PSLLDQ xmm2, 4 ; deja los dos segundo en las posiciones 3 y 4
PADDW xmm1, xmm2 ; deja en xmm1 los datos (9, 10, 11, 12, 0, 0, 0, 0)
MOVDQU xmm11, xmm1 ; deja en xmm10 este registro para usarlo después
; pasa a los siguientes 4 píxeles
LEA r14, [r14+12] ; aumenta 12 bytes para pasar a los siguientes
;Cuarta tanda
MOVDQU xmm0, [r14] ; pone en xmm0 la primera tirada de 16 bytes (|BGR, BGR, BGR, BGR|, BGR, B)
PXOR xmm15, xmm15 ; limpia xmm15
MOVDQU xmm1, xmm0 ; copia al xmm1 lo de memoria
MOVDQU xmm2, xmm0 ; copia al xmm2 lo de memoria
PUNPCKLBW xmm1, xmm15 ; pasa al xmm1 en tamaño word los primeros (|BGR, BGR|, BG)
PSLLDQ xmm2, 2 ; mueve dos bytes a derecha para que queden como parte baja los dos pixeles segundos o sea (00, BGR, BGR, |BGR, BGR|, BG)
PUNPCKHBW xmm2, xmm15 ; pasa al xmm1 en tamaño word los segundos (|BGR, BGR|, BG)
; cálculo HIGH
MOVDQU xmm3, xmm1 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm1 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm1, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm1, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
; cálculo LOW
MOVDQU xmm3, xmm2 ; pasa al xmm3 el xmm1 para operar
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (GR, BGR, BG0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1, G1+R1|, R1+B2, |B2+G2, G2+R2|, R2+B3, B3+G3, G3+0)
MOVDQU xmm3, xmm2 ; copia a xmm1 lo calculado antes
PSRLDQ xmm3, 2 ; mueve 2 bytes a izquierda (1 word, o sea una componente) queda (G1+R1, R1+B2, B2+G2, G2+R2, R2+B3, B3+G3, G3+0, 0)
PADDW xmm2, xmm3 ; deja en el xmm1 la suma o sea (|B1+G1+G1+R1|, G1+R1+R1+B2, R1+B2+B2+G2, |B2+G2+G2+R2|, G2+R2+R2+B3, R2+B3+B3+G3, B3+G3+G3+0, G3+0+0)
PSRAW xmm2, 2 ; mueve 2 bits en cada uno a derecha (o sea divide por 4 cada uno de los words)
;máscaras
MOVDQU xmm15, [maskPrimeroCuarto] ; pone en xmm15 la máscara para filtrar primero y cuarto
PAND xmm1, xmm15 ; aplica la máscara
PAND xmm2, xmm15 ; aplica la máscara
MOVDQU xmm14, xmm1 ; pone en xmm14 a xmm1
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm1, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm1, xmm15 ; deja los primeros dos
MOVDQU xmm14, xmm2 ; pone en xmm14 a xmm2
PSRLDQ xmm14, 4 ; mueve a izquierda 4 bytes (o sea 2 words)
PADDW xmm2, xmm14 ; deja en xmm1 (primero, segundo, basura, basura, basura, basura, basura, basura)
MOVDQU xmm15, [maskPrimerosDos] ; pone en xmm15 la máscara para dejar sólo los primeros dos
PAND xmm2, xmm15 ; deja los primeros dos
PSLLDQ xmm2, 4 ; deja los dos segundo en las posiciones 3 y 4
PADDW xmm1, xmm2 ; deja en xmm1 los datos (13, 14, 15, 16, 0, 0, 0, 0)
PSLLDQ xmm1, 8 ; pasa a derecha 8 bytes (words) para tener (0, 0, 0, 0, 13, 14, 15, 16)
PADDW xmm11, xmm1 ; deja en xmm10 (9, 10, 11, 12, 13, 14, 15, 16)
; pasa a los siguientes 4 píxeles
LEA r14, [r14+12] ; aumenta 12 bytes para pasar a los siguientes
PACKUSWB xmm10, xmm11 ; pone en xmm11 los words de xmm10 y xmm11 en ese orden pero ahora como bytes
MOVDQU xmm0, xmm10 ; pasa a xmm0 los datos a imprimir
MOVDQU [r13], xmm0 ; imprime en dst los datos
LEA r13, [r13+16] ; pasa a los siguientes 16 del dst
SUB r11, 16; resto 16 columna
JMP cicloPorColumnaMU
redimensionarMU:
MOV rax, 16; Que es la cantidad de pixels que escribo en momoria
SUB rax, r11; Resto la cant de columnas que me faltan procesar
SUB r13, rax; Retrocedo en el dst la diferencia entre la cantidad de columnas que procese y 16
SUB r14 ,rax;Retrocedo en el src diferencia*3 (porque 1 px = 3b)
SUB r14 ,rax;
SUB r14 ,rax;
MOV r11,16; Para que termine justo
JMP cicloPorColumnaMU
cambiarDeFilaMU:
LEA rdi, [rdi + r8]; sumo el row_size
LEA rsi, [rsi + r9]; sumo el row_size
DEC rdx; resto 1 fila
JMP cicloPorFilaMU
salirMU:
POP r14
POP r13
POP rbp
RET
|
Task/Heronian-triangles/AppleScript/heronian-triangles.applescript | mbirabhadra/RosettaCodeData | 1 | 1705 | <filename>Task/Heronian-triangles/AppleScript/heronian-triangles.applescript<gh_stars>1-10
use framework "Foundation"
property ca : current application
-- heroniansOfSideUpTo :: Int -> [(Int, Int, Int)]
on heroniansOfSideUpTo(n)
script sideA
on lambda(a)
script sideB
on lambda(b)
script sideC
-- primitiveHeronian :: Int -> Int -> Int -> Bool
on primitiveHeronian(x, y, z)
(x ≤ y and y ≤ z) and (x + y > z) and ¬
gcd(gcd(x, y), z) = 1 and ¬
isIntegerValue(hArea(x, y, z))
end primitiveHeronian
on lambda(c)
if primitiveHeronian(a, b, c) then
[[a, b, c]]
else
[]
end if
end lambda
end script
concatMap(sideC, range(b, n))
end lambda
end script
concatMap(sideB, range(a, n))
end lambda
end script
concatMap(sideA, range(1, n))
end heroniansOfSideUpTo
-- TEST
on run
set n to 200
set lstHeron to sortByKeys(map(triangleDimensions, ¬
heroniansOfSideUpTo(n)), ¬
{"area", "perimeter", "maxSide"})
set lstCols to {"sides", "perimeter", "area"}
set lstColWidths to [20, 15, 0]
set area to 210
script areaFilter
-- Record -> [Record]
on lambda(recTriangle)
if area of recTriangle = area then
[recTriangle]
else
[]
end if
end lambda
end script
intercalate("
", {("Number of triangles found (with sides <= 200): " & ¬
length of lstHeron as string), ¬
¬
tabulation("First 10, ordered by area, perimeter, longest side", ¬
items 1 thru 10 of lstHeron, lstCols, lstColWidths), ¬
¬
tabulation("Area = 210", ¬
concatMap(areaFilter, lstHeron), lstCols, lstColWidths)})
end run
-- triangleDimensions :: (Int, Int, Int) ->
-- {sides: (Int, Int, Int), area: Int, perimeter: Int, maxSize: Int}
on triangleDimensions(lstSides)
set {x, y, z} to lstSides
{sides:[x, y, z], area:hArea(x, y, z) as integer, perimeter:x + y + z, maxSide:z}
end triangleDimensions
-- hArea :: Int -> Int -> Int -> Num
on hArea(x, y, z)
set s to (x + y + z) / 2
set a to s * (s - x) * (s - y) * (s - z)
if a > 0 then
a ^ 0.5
else
0
end if
end hArea
-- gcd :: Int -> Int -> Int
on gcd(m, n)
if n = 0 then
m
else
gcd(n, m mod n)
end if
end gcd
-- TABLE FORMATTING
-- tabulation :: [Record] -> [String] -> String -> [Integer] -> String
on tabulation(strLegend, lstRecords, lstKeys, lstWidths)
script heading
on lambda(strTitle, iCol)
set str to toCapitalized(strTitle)
str & nreps(space, (item iCol of lstWidths) - (length of str))
end lambda
end script
script lineString
on lambda(rec)
script fieldString
-- fieldString :: String -> Int -> String
on lambda(strKey, i)
set v to keyValue(rec, strKey)
if class of v is list then
set strData to ("(" & intercalate(", ", v) & ")")
else
set strData to v as string
end if
strData & nreps(space, (item i of (lstWidths)) - (length of strData))
end lambda
end script
tab & intercalate(tab, map(fieldString, lstKeys))
end lambda
end script
strLegend & ":" & linefeed & linefeed & ¬
tab & intercalate(tab, ¬
map(heading, lstKeys)) & linefeed & ¬
intercalate(linefeed, map(lineString, lstRecords))
end tabulation
-- isIntegerValue :: Num -> Bool
on isIntegerValue(n)
{real, integer} contains class of n and (n = (n as integer))
end isIntegerValue
-- sortByKeys :: [Record] -> [String] -> [Record]
on sortByKeys(lstRecords, lstKeys)
script keyDescriptor
on lambda(strKey)
ca's NSSortDescriptor's ¬
sortDescriptorWithKey:(strKey) ascending:true
end lambda
end script
((ca's NSArray's arrayWithArray:lstRecords)'s ¬
sortedArrayUsingDescriptors:(map(keyDescriptor, lstKeys))) as list
end sortByKeys
-- keyValue :: Record -> String -> a
on keyValue(rec, strKey)
item 1 of ((ca's NSArray's ¬
arrayWithObject:((ca's NSDictionary's dictionaryWithDictionary:rec)'s ¬
objectForKey:strKey)) as list)
end keyValue
-- GENERIC FUNCTIONS
-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
script append
on lambda(a, b)
a & b
end lambda
end script
foldl(append, {}, map(f, xs))
end concatMap
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to lambda(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to lambda(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- range :: Int -> Int -> [Int]
on range(m, n)
set d to 1
if n < m then set d to -1
set lst to {}
repeat with i from m to n by d
set end of lst to i
end repeat
return lst
end range
-- intercalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
set {dlm, my text item delimiters} to {my text item delimiters, strText}
set strJoined to lstText as text
set my text item delimiters to dlm
return strJoined
end intercalate
-- Text -> Text
on toCapitalized(str)
((ca's NSString's stringWithString:(str))'s ¬
capitalizedStringWithLocale:(ca's NSLocale's currentLocale())) as text
end toCapitalized
-- String -> Int -> String
on nreps(s, n)
set o to ""
if n < 1 then return o
repeat while (n > 1)
if (n mod 2) > 0 then set o to o & s
set n to (n div 2)
set s to (s & s)
end repeat
return o & s
end nreps
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property lambda : f
end script
end if
end mReturn
|
src/core/config.ads | Okasu/Byron | 1 | 24709 | <filename>src/core/config.ads<gh_stars>1-10
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Plugin; use Plugin;
package Config
is
Channels : Plugin.Vectors.Vector;
Port : Integer;
Prefix : Character;
Server, Nick, Password, Owner : Unbounded_String;
procedure Parse (File_Name : String);
end Config;
|
pygoslin/data/goslin/Goslin.g4 | n-elie/pygoslin | 0 | 1249 | <gh_stars>0
/*
* MIT License
*
* Copyright (c) 2017 <NAME> - dominik.kopczynski {at} isas.de
* <NAME> - bing.peng {at} isas.de
* <NAME> - nils.hoffmann {at} isas.de
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the 'Software'), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:;
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHether IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/* This is a BNF / ANTLR4 grammar for lipid subspecies identifiers following
* J.K. Pauling et al. 2017, PLoS One, 12(11):e0188394.
*/
grammar Goslin;
/* first rule is always start rule */
lipid : lipid_eof EOF;
lipid_eof : lipid_pure | lipid_pure adduct_info;
lipid_pure : gl | pl | sl | sterol | mediatorc | saccharolipid;
/* adduct information */
adduct_info : '[M' adduct ']' charge charge_sign | adduct_separator '[M' adduct ']' charge charge_sign;
adduct : '+H' | '+2H' | '+NH4' | '-H' | '-2H' | '+HCOO' | '+CH3COO' | charge_sign arbitrary_adduct;
arbitrary_adduct : adduct4 | adduct4 adduct4;
adduct4 : adduct2 | adduct2 adduct2;
adduct2 : character | character character;
fa2 : fa2_unsorted | fa2_sorted;
fa2_unsorted: fa DASH fa | fa UNDERSCORE fa;
fa2_sorted: fa SLASH fa | fa BACKSLASH fa;
fa3 : fa3_unsorted | fa3_sorted;
fa3_unsorted: fa DASH fa DASH fa | fa UNDERSCORE fa UNDERSCORE fa;
fa3_sorted: fa SLASH fa SLASH fa | fa BACKSLASH fa BACKSLASH fa;
fa4 : fa4_unsorted | fa4_sorted;
fa4_unsorted: fa DASH fa DASH fa DASH fa | fa UNDERSCORE fa UNDERSCORE fa UNDERSCORE fa;
fa4_sorted: fa SLASH fa SLASH fa SLASH fa | fa BACKSLASH fa BACKSLASH fa BACKSLASH fa;
/* glycerolipid rules (7 classes) */
gl : sqml | mgl | dgl | sgl | tgl;
sqml : hg_sqml_full headgroup_separator fa;
mgl : hg_mgl_full headgroup_separator fa;
dgl : hg_dgl_full headgroup_separator gl_species | hg_dgl_full headgroup_separator dgl_subspecies;
sgl : hg_sgl_full headgroup_separator gl_species | hg_sgl_full headgroup_separator dgl_subspecies;
tgl : hg_tgl_full headgroup_separator gl_species | hg_tgl_full headgroup_separator tgl_subspecies;
gl_species : fa;
dgl_subspecies : fa2;
tgl_subspecies : fa3;
hg_sqml_full : hg_sqml | hg_mgl heavy_hg;
hg_mgl_full : hg_mgl | hg_mgl heavy_hg;
hg_dgl_full : hg_dgl | hg_dgl heavy_hg;
hg_sgl_full : hg_sgl | hg_sgl heavy_hg;
hg_tgl_full : hg_tgl | hg_tgl heavy_hg;
hg_sqml : 'SQMG';
hg_mgl : 'MAG';
hg_dgl : 'DAG';
hg_sgl : 'MGDG' | 'DGDG' | 'SQDG';
hg_tgl : 'TAG';
/* phospholipid rules (56 classes) */
pl : lpl | dpl | tpl | pl_o | cl | mlcl | dlcl;
pl_o : lpl_o | dpl_o;
lpl : hg_lplc headgroup_separator fa;
lpl_o : hg_lpl_oc plasmalogen_separator fa;
dpl : hg_plc headgroup_separator pl_species | hg_plc headgroup_separator pl_subspecies;
tpl : hg_tplc headgroup_separator pl_species | hg_tplc headgroup_separator tpl_subspecies;
dpl_o : hg_pl_oc plasmalogen_separator pl_species | hg_pl_oc plasmalogen_separator pl_subspecies;
dlcl : hg_dlclc headgroup_separator pl_species | hg_dlclc headgroup_separator dlcl_subspecies;
mlcl : hg_mlclc headgroup_separator pl_species | hg_mlclc headgroup_separator mlcl_subspecies;
cl : hg_clc headgroup_separator pl_species | hg_clc headgroup_separator cl_subspecies;
pl_species : fa;
pl_subspecies : fa2;
tpl_subspecies : fa3;
dlcl_subspecies : fa2;
mlcl_subspecies : fa3;
cl_subspecies : fa4;
heavy_hg : heavy;
hg_clc : hg_cl | hg_cl heavy_hg;
hg_cl : 'CL';
hg_mlclc : hg_mlcl | hg_mlcl heavy_hg;
hg_mlcl : 'MLCL';
hg_dlclc : hg_dlcl | hg_dlcl heavy_hg;
hg_dlcl : 'DLCL';
hg_plc : hg_pl | hg_pl heavy_hg;
hg_pl : 'BMP' | 'CDP-DAG' | 'DMPE' | 'MMPE' | 'PA' | 'PC' | 'PE' | 'PEt' | 'PG' | 'PI' | hg_pip | 'PS' | 'LBPA' | 'PGP' | 'PPA' | 'Glc-GP' | '6-Ac-Glc-GP' | hg_pim | 'PnC' | 'PnE' | 'PT' | 'PE-NMe2' | 'PE-NMe' | 'PIMIP' | 'CDPDAG';
hg_pim : 'PIM' hg_pim_number;
hg_pim_number : number;
hg_pip : hg_pip_pure | hg_pip_pure hg_pip_m | hg_pip_pure hg_pip_d | hg_pip_pure hg_pip_t;
hg_pip_pure : 'PIP';
hg_pip_m : '[3\']' | '[4\']' | '[5\']';
hg_pip_d : '2' | '2[3\',4\']' | '2[4\',5\']' | '2[3\',5\']';
hg_pip_t : '3' | '3[3\',4\',5\']';
hg_tplc : hg_tpl | hg_tpl heavy_hg;
hg_tpl : 'SLBPA' | 'NAPE';
hg_lplc : hg_lpl | hg_lpl heavy_hg;
hg_lpl : 'LPA' | 'LPC' | 'LPE' | 'LPG' | 'LPI' | 'LPS' | hg_lpim | 'CPA' | 'LCDPDAG' | 'LDMPE' | 'LMMPE' | 'LPIMIP' | 'LPIN';
hg_lpim : 'LPIM' hg_lpim_number;
hg_lpim_number : number;
hg_lpl_oc : hg_lpl_o ' O' | hg_lpl_o heavy_hg ' O';
hg_lpl_o : 'LPC' | 'LPE';
hg_pl_oc : hg_pl_o ' O' | hg_pl_o heavy_hg ' O';
hg_pl_o : 'PA' | 'PC' | 'PE' | 'PG' | 'PI' | 'PS';
/* sphingolipid rules (21) */
sl : lsl | dsl;
lsl : hg_lslc headgroup_separator lcb;
dsl : hg_dslc headgroup_separator sl_species | hg_dslc headgroup_separator sl_subspecies;
sl_species : lcb;
sl_subspecies : lcb sorted_fa_separator fa;
hg_lslc : hg_lsl | hg_lsl heavy_hg;
hg_lsl : 'LCB' | 'LCBP' | 'LHexCer' | 'LSM';
hg_dslc : hg_dsl | hg_dsl heavy_hg;
hg_dsl : 'Cer' | 'CerP' | 'EPC' | 'GB4' | 'GD3' | 'GB3' | 'GM3' | 'GM4' | 'Hex3Cer' | 'Hex2Cer' | 'HexCer' | 'IPC' | 'M(IP)2C' | 'MIPC' | 'SHexCer' | 'SM' | 'FMC-5' | 'FMC-6' ;
/* sterol lipids (2 classes) */
sterol : stc | ste | stes;
stc : st | st heavy_hg;
st : 'Ch' | 'Cholesterol' | 'ST 27:1;1' | 'ST 27:2;1' | 'ST 28:3;1' | 'ST 30:2;1' | 'ST 29:2;1' | 'ST 28:2;1';
ste : hg_stc sorted_fa_separator fa;
stes : hg_stcs headgroup_separator fa;
hg_stc : hg_ste | hg_ste heavy_hg;
hg_ste : 'SE 27:1' | 'SE 27:2' | 'SE 28:3' | 'SE 30:2' | 'SE 29:2' | 'SE 28:2';
hg_stcs : hg_stes | hg_stes heavy_hg;
hg_stes : 'ChE' | 'CE';
/* mediator lipids (1 class) */
mediatorc : mediator | mediator heavy_hg;
mediator : '10-HDoHE' | '11-HDoHE' | '11-HETE' | '11,12-DHET' | '11(12)-EET'| '12-HEPE' | '12-HETE' | '12-HHTrE' | '12-OxoETE' | '12(13)-EpOME' | '13-HODE' | '13-HOTrE' | '14,15-DHET' | '14(15)-EET' | '14(15)-EpETE' | '15-HEPE' | '15-HETE' | '15d-PGJ2' | '16-HDoHE' | '16-HETE' | '18-HEPE' | '5-HEPE' | '5-HETE' | '5-HpETE' | '5-OxoETE' | '5,12-DiHETE' | '5,6-DiHETE' | '5,6,15-LXA4' | '5(6)-EET' | '8-HDoHE' | '8-HETE' | '8,9-DHET' | '8(9)-EET' | '9-HEPE' | '9-HETE' | '9-HODE' | '9-HOTrE' | '9(10)-EpOME' | 'AA' | 'alpha-LA' | 'DHA' | 'EPA' | 'Linoleic acid' | 'LTB4' | 'LTC4' | 'LTD4' | 'Maresin 1' | 'Palmitic acid' | 'PGB2' | 'PGD2' | 'PGE2' | 'PGF2alpha' | 'PGI2' | 'Resolvin D1' | 'Resolvin D2' | 'Resolvin D3' | 'Resolvin D5' | 'tetranor-12-HETE' | 'TXB1' | 'TXB2' | 'TXB3';
/* saccharolipids rules (3 classes) */
saccharolipid : sac_di | sac_f;
sac_di : hg_sac_di_c headgroup_separator sac_species | hg_sac_di_c headgroup_separator sac_di_subspecies;
hg_sac_di_c : hg_sac_di | hg_sac_di heavy_hg;
hg_sac_di : 'DAT' | 'AC2SGL';
sac_f : hg_sac_f_c headgroup_separator sac_species | hg_sac_f_c headgroup_separator sac_f_subspecies;
hg_sac_f_c : hg_sac_f | hg_sac_f heavy_hg;
hg_sac_f : 'PAT16' | 'PAT18';
sac_species : fa;
sac_di_subspecies : fa2;
sac_f_subspecies : fa4;
/* generic rules */
fa : fa_pure | fa_pure heavy_fa | fa_pure ether | fa_pure ether heavy_fa;
heavy_fa : heavy;
fa_pure : carbon carbon_db_separator db | carbon carbon_db_separator db db_hydroxyl_separator hydroxyl;
ether : 'a' | 'p';
lcb : lcb_pure | lcb_pure heavy_lcb;
heavy_lcb : heavy;
lcb_pure : carbon carbon_db_separator db db_hydroxyl_separator hydroxyl | old_hydroxyl carbon carbon_db_separator db;
carbon : number;
db : db_count | db_count db_positions;
db_count : number;
db_positions : ROB db_position RCB;
db_position : db_single_position | db_position db_position_separator db_position;
db_single_position : db_position_number | db_position_number cistrans;
db_position_number : number;
cistrans : 'E' | 'Z';
hydroxyl : number;
old_hydroxyl : 'd' | 't';
number : digit;
digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | digit digit;
heavy : '(+' isotopes ')';
isotopes : isotopes isotopes | isotope;
isotope : '[' isotope_number ']' isotope_element isotope_count | '[' isotope_number ']' isotope_element;
isotope_number : number;
isotope_element : element;
isotope_count : number;
element : 'C' | 'H' | 'O' | 'N' | 'P' | 'S';
/* separators */
SPACE : ' ';
COLON : ':';
SEMICOLON : ';';
DASH : '-';
UNDERSCORE : '_';
SLASH : '/';
BACKSLASH : '\\';
COMMA: ',';
ROB: '(';
RCB: ')';
FRAGMENT_SEPARATOR : ' - ';
sorted_fa_separator : SLASH | BACKSLASH;
adduct_separator : SPACE;
unsorted_fa_separator : DASH | UNDERSCORE;
plasmalogen_separator : headgroup_separator | DASH;
headgroup_separator : SPACE;
carbon_db_separator : COLON;
db_hydroxyl_separator : SEMICOLON;
db_position_separator : COMMA;
round_open_bracket : ROB;
round_close_bracket : RCB;
character : 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z' |'0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
charge : '1' | '2' | '3' | '4';
charge_sign : '-' | '+';
|
Working Disassembly/Levels/MHZ/Misc Object Data/Map - Swing Bar Vertical.asm | TeamASM-Blur/Sonic-3-Blue-Balls-Edition | 5 | 82305 | <filename>Working Disassembly/Levels/MHZ/Misc Object Data/Map - Swing Bar Vertical.asm
dc.w word_3F362-Map_MHZSwingBarVertical
word_3F362: dc.w 2 ; DATA XREF: ROM:0003F360o
dc.b $E0, 3, 0, 5, $FF, $FC
dc.b 0, 3, 0, 7, $FF, $FC
|
programs/oeis/070/A070478.asm | karttu/loda | 1 | 101873 | <reponame>karttu/loda
; A070478: a(n) = n^3 mod 16.
; 0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9,8,3,0,5,8,15,0,1,8,11,0,13,8,7,0,9
pow $0,3
mov $1,$0
mod $1,16
|
OpenInTerminal.applescript | hyperknot/iterm_in_forklift | 8 | 1061 | tell application "iTerm"
if (exists current window) then
tell current window to create tab with default profile
else
create window with default profile
end if
tell current session of current window
write text "cd _forklift_path_placeholder_"
write text "clear"
end tell
activate
end tell |
src/agda/FRP/JS/Event.agda | agda/agda-frp-js | 63 | 16094 | <reponame>agda/agda-frp-js
open import FRP.JS.RSet using ( RSet ; _⇒_ ; ⟦_⟧ ; ⟨_⟩ )
module FRP.JS.Event where
infixr 4 _∪_
postulate
Evt : RSet → RSet
map : ∀ {A B} → ⟦ A ⇒ B ⟧ → ⟦ Evt A ⇒ Evt B ⟧
∅ : ∀ {A} → ⟦ Evt A ⟧
_∪_ : ∀ {A} → ⟦ Evt A ⇒ Evt A ⇒ Evt A ⟧
accumBy : ∀ {A B} → ⟦ ⟨ B ⟩ ⇒ A ⇒ ⟨ B ⟩ ⟧ → B → ⟦ Evt A ⇒ Evt ⟨ B ⟩ ⟧
{-# COMPILED_JS map function(A) { return function(B) {
return function(f) { return function(s) { return function(e) {
return e.map(function (t,v) { return f(t)(v); });
}; }; };
}; } #-}
{-# COMPILED_JS ∅ function(A) { return require("agda.frp.signal").zero; } #-}
{-# COMPILED_JS _∪_ function(A) { return function(s) {
return function(x) { return function(y) { return x.merge(y); }; };
}; } #-}
{-# COMPILED_JS accumBy function(A) { return function(B) { return function(f) {
return function(b) { return function(s) { return function(e) {
return e.accumBy(function(t,b,a) { return f(t)(b)(a); },b);
}; }; };
}; }; } #-}
tag : ∀ {A B} → ⟦ B ⟧ → ⟦ Evt A ⇒ Evt B ⟧
tag b = map (λ _ → b) |
cli/osalang/osacompile -o name.app/osacompile -o name.app source.applescript | looking-for-a-job/applescript-examples | 1 | 4045 | #!/bin/sh
osacompile -o name.app source.applescript
|
tests/inputs/test_dep_inst/test_addi_dep_inst/addi_dep.asm | danielstumpp/tomasulo-simulator | 0 | 21068 | Addi, R5, R5, 100
Addi, R6, R5, 15 |
libsrc/stdio/ansi/oz/f_ansi_scrollup.asm | meesokim/z88dk | 0 | 166382 | ;
; ANSI Video handling for Sharp OZ family
;
; Scrollup
;
; <NAME> - Nov. 2002
;
; $Id: f_ansi_scrollup.asm,v 1.5 2015/01/19 01:33:18 pauloscustodio Exp $
;
PUBLIC ansi_SCROLLUP
EXTERN base_graphics
EXTERN swapgfxbk
EXTERN swapgfxbk1
.ansi_SCROLLUP
call swapgfxbk
ld hl,(base_graphics)
ld d,h
ld e,l
ld bc,0f0h
add hl,bc
ld bc,2160
;ld bc,2160-0f0h
ldir
ld de,0f0h
sbc hl,de
ld d,h
ld e,l
xor a
ld (hl),a
inc de
ld bc,+(30*8)-1
ldir
jp swapgfxbk1
|
audio/music/meetprofoak.asm | adhi-thirumala/EvoYellow | 16 | 178214 | <reponame>adhi-thirumala/EvoYellow
Music_MeetProfOak_Ch1::
tempo 112
volume 7, 7
duty 3
toggleperfectpitch
notetype 12, 11, 4
octave 3
F# 1
B_ 1
octave 4
D# 1
E_ 1
F# 12
notetype 12, 10, 2
octave 3
E_ 6
B_ 10
E_ 6
B_ 10
E_ 6
D# 4
F# 2
F# 4
E_ 6
D# 4
F# 2
F# 4
E_ 6
B_ 10
E_ 6
B_ 10
E_ 6
D# 4
F# 2
F# 4
E_ 6
D# 4
F# 2
F# 4
Music_MeetProfOak_branch_af85::
F# 6
E_ 4
A_ 2
A_ 4
F# 6
E_ 4
A_ 2
A_ 4
F# 6
E_ 4
G# 2
G# 4
F# 6
E_ 4
G# 2
G# 4
E_ 6
D# 4
F# 2
F# 4
E_ 6
D# 4
F# 2
F# 4
F# 6
E_ 4
G# 2
G# 4
F# 6
E_ 4
G# 2
G# 4
loopchannel 0, Music_MeetProfOak_branch_af85
Music_MeetProfOak_Ch2::
vibrato 8, 1, 1
duty 2
notetype 12, 12, 4
octave 3
B_ 1
octave 4
D# 1
F# 1
A# 1
B_ 12
notetype 12, 11, 2
octave 3
B_ 2
octave 4
C# 2
D# 2
E_ 4
D# 2
C# 4
notetype 12, 6, 4
octave 4
B_ 2
octave 5
C# 2
D# 2
E_ 4
D# 2
C# 4
notetype 12, 11, 2
octave 3
B_ 2
A_ 2
G# 2
A_ 4
B_ 2
B_ 4
notetype 12, 8, 1
octave 4
B_ 2
A_ 2
G# 2
A_ 4
B_ 2
B_ 4
notetype 12, 11, 2
octave 3
B_ 2
octave 4
C# 2
D# 2
E_ 4
D# 2
C# 4
notetype 12, 6, 4
octave 4
B_ 2
octave 5
C# 2
D# 2
E_ 4
D# 2
C# 4
notetype 12, 11, 2
octave 3
B_ 2
A_ 2
G# 2
A_ 4
B_ 2
B_ 4
notetype 12, 8, 1
octave 4
B_ 2
A_ 2
G# 2
A_ 4
B_ 2
B_ 4
notetype 12, 11, 5
Music_MeetProfOak_branch_b005::
octave 4
C# 6
octave 3
A_ 1
octave 4
C# 1
E_ 6
C# 1
E_ 1
F# 4
E_ 4
D# 4
C# 4
octave 3
B_ 6
G# 1
B_ 1
octave 4
E_ 8
notetype 12, 6, 5
octave 4
B_ 6
G# 1
B_ 1
octave 5
E_ 8
notetype 12, 11, 5
octave 3
A_ 6
F# 1
A_ 1
octave 4
D# 8
E_ 4
D# 4
C# 4
C_ 4
octave 3
B_ 6
G# 1
B_ 1
octave 4
E_ 6
octave 3
B_ 1
octave 4
E_ 1
notetype 12, 11, 7
G# 16
loopchannel 0, Music_MeetProfOak_branch_b005
Music_MeetProfOak_Ch3::
notetype 12, 1, 2
rest 10
octave 4
F# 1
rest 1
B_ 1
rest 1
octave 5
C# 1
rest 1
octave 4
B_ 1
rest 5
octave 5
E_ 4
rest 6
octave 4
B_ 1
rest 5
octave 5
E_ 4
octave 4
F# 1
rest 1
B_ 1
rest 1
octave 5
C# 1
rest 1
octave 4
F# 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
B_ 1
rest 1
E_ 1
rest 1
A_ 1
rest 1
B_ 1
rest 1
F# 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
B_ 1
rest 1
F# 1
rest 1
G_ 1
rest 1
G# 1
rest 1
Music_MeetProfOak_branch_b0bc::
octave 4
A_ 1
rest 1
octave 5
C# 1
rest 1
octave 4
A_ 1
rest 1
octave 5
C# 1
rest 1
octave 4
A_ 1
rest 1
octave 5
C# 1
rest 1
octave 4
A_ 1
rest 1
octave 5
C# 1
rest 1
loopchannel 2, Music_MeetProfOak_branch_b0bc
Music_MeetProfOak_branch_b0d8::
octave 4
G# 1
rest 1
B_ 1
rest 1
G# 1
rest 1
B_ 1
rest 1
G# 1
rest 1
B_ 1
rest 1
G# 1
rest 1
B_ 1
rest 1
loopchannel 2, Music_MeetProfOak_branch_b0d8
Music_MeetProfOak_branch_b0ed::
F# 1
rest 1
A_ 1
rest 1
F# 1
rest 1
A_ 1
rest 1
F# 1
rest 1
A_ 1
rest 1
F# 1
rest 1
A_ 1
rest 1
loopchannel 2, Music_MeetProfOak_branch_b0ed
Music_MeetProfOak_branch_b101::
G# 1
rest 1
B_ 1
rest 1
G# 1
rest 1
B_ 1
rest 1
G# 1
rest 1
B_ 1
rest 1
G# 1
rest 1
B_ 1
rest 1
loopchannel 2, Music_MeetProfOak_branch_b101
loopchannel 0, Music_MeetProfOak_branch_b0bc
|
MD407/Kap2/assignconst.asm | konglobemeralt/DAT017 | 0 | 165901 | <filename>MD407/Kap2/assignconst.asm<gh_stars>0
LDR R1, =c
LDRB R0, ='A'
STRB R0, [R1]
LDR R1, =s
LDRH R0, =1000
STRH R0, [R1]
LDR R1, =i
LDR R0, =100000
STR R0, [R1]
.ALIGN
i: .WORD 4
s: .HWORD 2
c: .BYTE 1
|
proglangs-learning/Agda/sv20/exam2.agda | helq/old_code | 0 | 5094 | <gh_stars>0
module sv20.exam2 where
-------------------------- FIRST TASK PREPARATION CODE --------------------------
open import Data.Unit using (⊤; tt)
open import Data.Product using (_×_ ; ∃) renaming (_,_ to ⟨_,_⟩)
open import Relation.Nullary using (¬_)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Function using (_∘_)
import Relation.Binary.PropositionalEquality as Eq
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _≡⟨_⟩_; _≡˘⟨_⟩_; _∎)
open Eq using (_≡_; refl; cong; sym; trans)
Subset : (A : Set) -> Set _
Subset A = A → Set
_∈_ : ∀ {A} → A → Subset A → Set
a ∈ P = P a
Relation : ∀ A B → Set₁
Relation A B = Subset (A × B)
Range : ∀ {A B} → Relation A B → Subset B
Range R b = ∃ (R ∘ ⟨_, b ⟩) -- equivalent to ∃ \a → R ⟨ a , b ⟩
Dom : ∀ {A B} → Relation A B → Subset A
Dom R a = ∃ (R ∘ ⟨ a ,_⟩) -- equivalent to ∃ \b → R ⟨ a , b ⟩
_⊆_ : ∀ {A} → Subset A → Subset A → Set
A ⊆ B = ∀ x → x ∈ A → x ∈ B
_∩_ : ∀ {A} → Subset A → Subset A → Subset A
A ∩ B = λ x → x ∈ A × x ∈ B
_∪_ : ∀ {A} → Subset A → Subset A → Subset A
A ∪ B = λ x → x ∈ A ⊎ x ∈ B
_/_ : ∀ {A} → Subset A → Subset A → Subset A
A / B = λ x → x ∈ A × ¬ (x ∈ B)
postulate
⊆→≡ : ∀ {a} {A B : Subset a} → A ⊆ B → B ⊆ A → A ≡ B
-------------------------- Solution to TASK 1 --------------------------
diff-theorem-3 : ∀ {a} {A B : Subset a}
→ (A / (A ∩ B)) ≡ (A / B)
-- The proof is divided in two parts, forwards (right contained in left) and
-- backwards (left contained in right)
diff-theorem-3 = ⊆→≡ diff-theorem-3→ diff-theorem-3←
where
diff-theorem-3→ : ∀ {a} {A B : Subset a}
→ (A / (A ∩ B)) ⊆ (A / B)
diff-theorem-3→ x x∈A/A∩B = -- Given an x such that `x ∈ (A / (A ∩ B))`
let
⟨ x∈A , ¬x∈A∩B ⟩ = x∈A/A∩B -- (1) By def. of diff, we have that `x ∈ A` and `¬ x ∈ A ∩ B`
¬x∈B = -- (2) Proof by contradiction that ¬ x ∈ B
λ{ x∈B → -- (a) Suppose `x ∈ B`
let x∈A∩B = ⟨ x∈A , x∈B ⟩ -- (b) then by def. of ∩ and (1) (a), we have that `x ∈ A ∩ B`
in ¬x∈A∩B x∈A∩B } -- Contradiction `x ∈ A ∩ B` (b) and `¬ x ∈ A ∩ B` (1).
x∈A/B = ⟨ x∈A , ¬x∈B ⟩ -- From (1), (2) and by def. of /, we have that `x ∈ A / B`
in x∈A/B -- QED
--Proof without comments
--diff-theorem-3→ x ⟨ x∈A , ¬x∈A∩B ⟩ = ⟨ x∈A , (λ{x∈B → ¬x∈A∩B ⟨ x∈A , x∈B ⟩}) ⟩
diff-theorem-3← : ∀ {a} {A B : Subset a}
→ (A / B) ⊆ (A / (A ∩ B))
diff-theorem-3← x x∈A/B = -- Given an x such that `x ∈ A / B`
let
⟨ x∈A , ¬x∈B ⟩ = x∈A/B -- (1) By def. of diff, we have that `x ∈ A` and `¬ x ∈ B`
¬x∈A∩B = -- (2) Proof by contradiction that `¬ x ∈ A ∩ B`
λ{ x∈A∩B → -- (a) Suppose `x ∈ A ∩ B`
let ⟨ x∈A , x∈B ⟩ = x∈A∩B -- (b) then by def. of ∩, we have that `x ∈ A` and `x ∈ B`
in ¬x∈B x∈B } -- Contraduction `x ∈ B` (b) and `¬ x ∈ B` (1)
x∈A/A∩B = ⟨ x∈A , ¬x∈A∩B ⟩ -- From (1), (2) and by the def. of /, `x ∈ (A / (A ∩ B))`
in x∈A/A∩B -- QED
--Proof without comments
--diff-theorem-3← x ⟨ x∈A , ¬x∈B ⟩ = ⟨ x∈A , (λ{⟨ x∈A , x∈B ⟩ → ¬x∈B x∈B}) ⟩
-- This might be another way to prove it, it still seems to require some postulate to work
--diff-theorem-3` : ∀ {a} {A B : Subset a}
-- (y : a)
-- → y ∈ (A / (A ∩ B)) ≡ y ∈ (A / B)
---- The proof is divided in two parts, forwards (right contained in left) and
---- backwards (left contained in right)
--diff-theorem-3` {_} {A} {B} y =
-- begin
-- y ∈ (A / (A ∩ B))
-- ≡⟨⟩
-- (A / (A ∩ B)) y
-- ≡⟨⟩
-- (A y × ¬ (A y × B y))
-- ≡⟨ cong (A y ×_) ? ⟩
-- (A y × ¬ (B y))
-- ≡⟨⟩
-- (A / B) y
-- ≡⟨⟩
-- y ∈ (A / B)
-- ∎
-------------------------- END FIRST TASK --------------------------
-------------------------- SECOND TASK PREPARATION CODE --------------------------
open import Data.List using (List; []; _∷_; _++_; length; reverse; map; foldr; downFrom; foldl)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
open import Data.Nat.Properties using (*-identityʳ; +-identityʳ; *-assoc)
pattern [_] z = z ∷ []
product : List ℕ → ℕ
product [] = 1
product (n ∷ ns) = n * product ns
-------------------------- Solution to TASK 2 --------------------------
of-singleton : ∀ (n : ℕ) → product [ n ] ≡ n
of-singleton n =
begin
product [ n ] ≡⟨⟩
product (n ∷ []) ≡⟨⟩
n * product [] ≡⟨⟩
n * 1 ≡⟨ *-identityʳ n ⟩
n
∎
of-join : ∀ (ms ns : List ℕ)
→ product (ms ++ ns) ≡ (product ms) * (product ns)
of-join [] ns =
begin
product ([] ++ ns) ≡⟨⟩
product ns ≡˘⟨ +-identityʳ (product ns) ⟩ -- product ns ≡ 1 * product ns
1 * product ns ≡⟨⟩
product [] * product ns
∎
of-join (m ∷ ms) ns =
begin
product ((m ∷ ms) ++ ns) ≡⟨⟩
product (m ∷ (ms ++ ns)) ≡⟨⟩
m * product (ms ++ ns) ≡⟨ cong (m *_) (of-join ms ns) ⟩ -- product (ms ++ ns) ≡ product ms * product ns
m * (product ms * product ns) ≡˘⟨ *-assoc m (product ms) (product ns) ⟩ -- * associativity
(m * product ms) * product ns ≡⟨⟩
product (m ∷ ms) * product ns
∎
-------------------------- END SECOND TASK --------------------------
|
Task/Empty-string/Ada/empty-string.ada | LaudateCorpus1/RosettaCodeData | 1 | 12015 | <reponame>LaudateCorpus1/RosettaCodeData
procedure Empty_String is
function Is_Empty(S: String) return Boolean is
begin
return S = ""; -- test that S is empty
end Is_Empty;
Empty: String := ""; -- Assign empty string
XXXXX: String := "Not Empty";
begin
if (not Is_Empty(Empty)) or Is_Empty(XXXXX) then
raise Program_Error with "something went wrong very very badly!!!";
end if;
end Empty_String;
|
oeis/010/A010910.asm | neoneye/loda-programs | 11 | 173844 | <reponame>neoneye/loda-programs<filename>oeis/010/A010910.asm
; A010910: Pisot sequence E(4,27): a(n) = floor(a(n-1)^2/a(n-2)+1/2) for n>1, a(0)=4, a(1)=27.
; Submitted by <NAME>(s1.)
; 4,27,182,1227,8272,55767,375962,2534607,17087452,115197747,776623742,5235731187,35297505832,237963690927,1604269674722,10815436502967,72913967391412,491560986863307,3313935758136902,22341419483137947,150618195689512192,1015416271552762887,6845588607764138282,46150613004348644127,311131621064912556172,2097542791411218557667,14140914853791874126862,95333203079807337549507,642703792747803395931352,4332888771885857063335647,29210851595054159359670642,196929553429754241474702087
add $0,3
mov $1,1
mov $3,1
lpb $0
sub $0,1
add $2,$3
mov $3,$1
mov $1,$2
mul $1,5
mul $2,6
lpe
sub $1,$3
mov $0,$1
div $0,50
|
alloy4fun_models/trashltl/models/4/iyLCJB6zbFeCxG8Av.als | Kaixi26/org.alloytools.alloy | 0 | 1521 | <gh_stars>0
open main
pred idiyLCJB6zbFeCxG8Av_prop5 {
always (some f:File | f not in File')
}
pred __repair { idiyLCJB6zbFeCxG8Av_prop5 }
check __repair { idiyLCJB6zbFeCxG8Av_prop5 <=> prop5o } |
lab3_test_harness/test/state_data_in/18.asm | Zaydax/PipelineProcessor | 2 | 18664 | <reponame>Zaydax/PipelineProcessor
.ORIG x1234
LDB R0, R6, #1
LDB R0, R6, #1
LDB R0, R6, #1
LDB R0, R6, #1
LDB R0, R6, #1
.END
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/machine_code1.adb | best08618/asylo | 7 | 3203 | -- { dg-do compile }
-- { dg-options "-gnatws" }
with System.Machine_Code; use System.Machine_Code;
procedure machine_code1 is
A_Float : Float;
An_Other_Float : Float := -99999.0;
begin
An_Other_Float := An_Other_Float - A_Float;
Asm("", Inputs => (Float'Asm_Input ("m", A_Float)));
end;
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/release_unc_maxalign.adb | best08618/asylo | 7 | 4002 | -- { dg-do run }
with Ada.Unchecked_Deallocation;
procedure Release_UNC_Maxalign is
type List is array (Natural range <>) of Integer;
for List'Alignment use Standard'Maximum_Alignment;
type List_Access is access all List;
procedure Release is new Ada.Unchecked_Deallocation
(Object => List, Name => List_Access);
My_List : List_Access;
begin
My_List := new List (1 .. 3);
Release (My_List);
end;
|
alloy4fun_models/trashltl/models/11/dXm7JkkD9uDtSoobv.als | Kaixi26/org.alloytools.alloy | 0 | 1798 | <filename>alloy4fun_models/trashltl/models/11/dXm7JkkD9uDtSoobv.als<gh_stars>0
open main
pred iddXm7JkkD9uDtSoobv_prop12 {
some f : Trash | after eventually f not in Trash or f in Trash
}
pred __repair { iddXm7JkkD9uDtSoobv_prop12 }
check __repair { iddXm7JkkD9uDtSoobv_prop12 <=> prop12o } |
programs/oeis/099/A099578.asm | karttu/loda | 1 | 173284 | <gh_stars>1-10
; A099578: a(n) = binomial(floor((3n+2)/2), floor(n/2)).
; 1,1,4,5,21,28,120,165,715,1001,4368,6188,27132,38760,170544,245157,1081575,1562275,6906900,10015005,44352165,64512240,286097760,417225900,1852482996,2707475148,12033222880,17620076360,78378960360,114955808528,511738760544,751616304549,3348108992991,4923689695575,21945588357420,32308782859535,144079707346575,212327989773900,947309492837400,1397281501935165,6236646703759395,9206478467454345
mov $1,$0
div $0,2
add $1,1
add $1,$0
bin $1,$0
|
programs/oeis/339/A339964.asm | neoneye/loda | 22 | 104715 | <reponame>neoneye/loda<filename>programs/oeis/339/A339964.asm
; A339964: a(n) = gcd(sigma(n), n+1).
; 1,3,4,1,6,1,8,3,1,1,12,1,14,3,8,1,18,1,20,21,2,1,24,5,1,3,4,1,30,1,32,3,2,1,12,1,38,3,8,1,42,1,44,3,2,1,48,1,1,3,4,1,54,5,8,3,2,1,60,1,62,3,8,1,6,1,68,3,2,1,72,1,74,3,4,7,6,1,80,3,1,1,84,1,2,3,8,1,90,13,4,3,2,1,24,1,98,9,4,1
mov $1,$0
add $0,2
seq $1,203 ; a(n) = sigma(n), the sum of the divisors of n. Also called sigma_1(n).
gcd $0,$1
|
programs/oeis/047/A047294.asm | karttu/loda | 1 | 175196 | ; A047294: Numbers that are congruent to {1, 2, 4, 6} mod 7.
; 1,2,4,6,8,9,11,13,15,16,18,20,22,23,25,27,29,30,32,34,36,37,39,41,43,44,46,48,50,51,53,55,57,58,60,62,64,65,67,69,71,72,74,76,78,79,81,83,85,86,88,90,92,93,95,97,99,100,102,104,106,107,109,111,113,114,116,118,120,121,123,125,127,128,130,132,134,135,137,139,141,142,144,146,148,149,151,153,155,156,158,160,162,163,165,167,169,170,172,174,176,177,179,181,183,184,186,188,190,191,193,195,197,198,200,202,204,205,207,209,211,212,214,216,218,219,221,223,225,226,228,230,232,233,235,237,239,240,242,244,246,247,249,251,253,254,256,258,260,261,263,265,267,268,270,272,274,275,277,279,281,282,284,286,288,289,291,293,295,296,298,300,302,303,305,307,309,310,312,314,316,317,319,321,323,324,326,328,330,331,333,335,337,338,340,342,344,345,347,349,351,352,354,356,358,359,361,363,365,366,368,370,372,373,375,377,379,380,382,384,386,387,389,391,393,394,396,398,400,401,403,405,407,408,410,412,414,415,417,419,421,422,424,426,428,429,431,433,435,436
mov $1,$0
mul $1,7
div $1,4
add $1,1
|
hott/equivalence/inverse.agda | HoTT/M-types | 27 | 3133 | <filename>hott/equivalence/inverse.agda
{-# OPTIONS --without-K #-}
module hott.equivalence.inverse where
open import level
open import sum
open import function.core
open import function.isomorphism.core
open import function.isomorphism.utils
open import function.isomorphism.properties
open import function.extensionality
open import function.overloading
open import equality.core
open import sets.unit
open import sets.nat.core using (suc)
open import hott.level
open import hott.equivalence.core
open import hott.equivalence.alternative
open import hott.univalence
module _ {i j}{A : Set i}{B : Set j} where
record inverse (f : A → B) : Set (i ⊔ j) where
constructor mk-inverse
field
g : B → A
α : (x : A) → g (f x) ≡ x
β : (y : B) → f (g y) ≡ y
isom : A ≅ B
isom = iso f g α β
iso⇒inv : (f : A ≅ B) → inverse (apply f)
iso⇒inv (iso f g α β) = mk-inverse g α β
inverse-struct-iso : (f : A → B)
→ inverse f
≅ ( Σ (B → A) λ g
→ Σ ((x : A) → g (f x) ≡ x) λ α
→ ((y : B) → f (g y) ≡ y) )
inverse-struct-iso f = record
{ to = λ { (mk-inverse g α β) → (g , α , β) }
; from = λ { (g , α , β) → (mk-inverse g α β) }
; iso₁ = λ _ → refl
; iso₂ = λ _ → refl }
≅-inv-struct-iso : (A ≅ B) ≅ Σ (A → B) inverse
≅-inv-struct-iso = trans≅ ≅-struct-iso
(Σ-ap-iso₂ (λ f → sym≅ (inverse-struct-iso f)))
ind-≈ : (P : ∀ {i}{A B : Set i} → A ≈ B → Set i)
→ (∀ {i}{A : Set i} → P {A = A} (≡⇒≈ refl))
→ ∀ {i}{A B : Set i}(eq : A ≈ B) → P eq
ind-≈ P d {A = A} eq = subst P (_≅_.iso₂ uni-iso eq)
(lem (≈⇒≡ eq))
where
lem : ∀ {i}{A B : Set i}
→ (p : A ≡ B)
→ P (≡⇒≈ p)
lem refl = d
inverse-nonprop' : ∀ {i}{A : Set i}
→ inverse (λ (x : A) → x)
≅ ((x : A) → x ≡ x)
inverse-nonprop' {i}{A} = begin
inverse id'
≅⟨ inverse-struct-iso id' ⟩
( Σ (A → A) λ g
→ Σ ((x : A) → g x ≡ x) λ α
→ ((y : A) → g y ≡ y) )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₁ strong-funext-iso ) ⟩
( Σ (A → A) λ g
→ Σ (g ≡ id') λ α
→ ((y : A) → g y ≡ y) )
≅⟨ sym≅ Σ-assoc-iso ⟩
( Σ (singleton' id') λ { (g , α)
→ ((y : A) → g y ≡ y) } )
≅⟨ trans≅ (Σ-ap-iso' (contr-⊤-iso (singl-contr' id'))
(λ _ → refl≅))
×-left-unit ⟩
((x : A) → x ≡ x)
∎
where
open ≅-Reasoning
id' : A → A
id' x = x
inverse-nonprop : ∀ {i}{A B : Set i}
→ (f : A → B)
→ weak-equiv f
→ inverse f
≅ ((x : A) → x ≡ x)
inverse-nonprop {i}{A} f we = ind-≈ P inverse-nonprop' (f , we)
where
P : ∀ {i}{A B : Set i} → A ≈ B → Set _
P {A = A} (f , we) = inverse f ≅ ((x : A) → x ≡ x)
|
Task/Loop-over-multiple-arrays-simultaneously/AppleScript/loop-over-multiple-arrays-simultaneously-2.applescript | mullikine/RosettaCodeData | 1 | 1811 | <reponame>mullikine/RosettaCodeData
-- CONCAT MAPPED OVER A TRANSPOSITION ----------------------------------------
on run
unlines(map(concat, transpose([["a", "b", "c"], ["A", "B", "C"], [1, 2, 3]])))
end run
-- GENERIC FUNCTIONS ---------------------------------------------------------
-- concat :: [[a]] -> [a] | [String] -> String
on concat(xs)
if length of xs > 0 and class of (item 1 of xs) is string then
set acc to ""
else
set acc to {}
end if
repeat with i from 1 to length of xs
set acc to acc & item i of xs
end repeat
acc
end concat
-- intercalate :: String -> [String] -> String
on intercalate(s, xs)
set {dlm, my text item delimiters} to {my text item delimiters, s}
set str to xs as text
set my text item delimiters to dlm
return str
end intercalate
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- transpose :: [[a]] -> [[a]]
on transpose(xss)
script column
on |λ|(_, iCol)
script row
on |λ|(xs)
item iCol of xs
end |λ|
end script
map(row, xss)
end |λ|
end script
map(column, item 1 of xss)
end transpose
-- unlines :: [String] -> String
on unlines(xs)
intercalate(linefeed, xs)
end unlines
|
programs/oeis/339/A339903.asm | neoneye/loda | 22 | 91849 | <reponame>neoneye/loda
; A339903: Fully multiplicative with a(p) = A000265(q-1), where q = A151800(p), the next prime > p.
; 1,1,1,1,3,1,5,1,1,3,3,1,1,5,3,1,9,1,11,3,5,3,7,1,9,1,1,5,15,3,9,1,3,9,15,1,5,11,1,3,21,5,23,3,3,7,13,1,25,9,9,1,29,1,9,5,11,15,15,3,33,9,5,1,3,3,35,9,7,15,9,1,39,5,9,11,15,1,41,3,1,21,11,5,27,23,15,3,3,3,5,7,9,13,33,1,25,25,3,9
seq $0,253885 ; Permutation of even numbers: a(n) = A003961(n+1) - 1.
seq $0,3958 ; If n = Product p(k)^e(k) then a(n) = Product (p(k)-1)^e(k).
lpb $0
dif $0,2
lpe
|
MegaTest.asm | tifa64/SIC-XE-Assembler- | 0 | 6346 | <gh_stars>0
COPY START 0
FIRST STL RETADR 17202D
LDB #LENGTH 69202D
BASE LENGTH
CLOOP +JSUB RDREC 4B101036
LDA LENGTH 032026
COMP #0 290000
JEQ ENDFIL 332007
+JSUB WRREC 4B10105D
J CLOOP 3F2FEC
ENDFIL LDA EOF 032010
STA BUFFER 0F2016
LDA #3 010003
STA LENGTH 0F200D
+JSUB WRREC 4B10105D
J @RETADR 3E2003
EOF BYTE C’EOF’ 454F46
RETADR RESW 1
LENGTH RESW 1
BUFFER RESB 4096
.
. READ RECORD INTO BUFFER
.
RDREC CLEAR X B410
CLEAR A B400
CLEAR S B440
+LDT #4096 75101000
RLOOP TD INPUT E32019
JEQ RLOOP 332FFA
RD INPUT DB2013
COMPR A,S A004
JEQ EXIT 332008
STCH BUFFER,X 57C003
TIXR T B850
JLT RLOOP 3B2FEA
EXIT STX LENGTH 134000
RSUB 4F0000
INPUT BYTE X'FI' F1
.
. SUBROUTINE TO WRITE RECORD FROM BUFFER
.
WRREC CLEAR X B410
LDT LENGTH 774000
WLOOP TD OUTPUT E32011
JEQ WLOOP 332FFA
LDCH BUFFER,X 53C003
WD OUTPUT DF2008
TIXR T B850
JLT WLOOP 3B2FEF
RSUB 4F0000
OUTPUT BYTE X'05' 05
END FIRST |
src/shipmodules.adb | thindil/steamsky | 80 | 25409 | -- Copyright 2016-2021 <NAME>
--
-- This file is part of Steam Sky.
--
-- Steam Sky is free software: you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- Steam Sky is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with Steam Sky. If not, see <http://www.gnu.org/licenses/>.
with Ada.Characters.Handling; use Ada.Characters.Handling;
with Ada.Strings.Maps; use Ada.Strings.Maps;
with DOM.Core; use DOM.Core;
with DOM.Core.Documents;
with DOM.Core.Nodes; use DOM.Core.Nodes;
with DOM.Core.Elements; use DOM.Core.Elements;
with Log; use Log;
with Items; use Items;
package body ShipModules is
procedure LoadShipModules(Reader: Tree_Reader) is
NodesList: Node_List;
ModulesData: Document;
TempRecord: BaseModule_Data;
Action: Data_Action;
ModuleNode: Node;
SkillIndex: Natural;
MaterialExists: Boolean;
ModuleIndex: Unbounded_String;
begin
ModulesData := Get_Tree(Reader);
NodesList :=
DOM.Core.Documents.Get_Elements_By_Tag_Name(ModulesData, "module");
Load_Modules_Loop :
for I in 0 .. Length(NodesList) - 1 loop
TempRecord :=
(Name => Null_Unbounded_String, MType => ENGINE, Weight => 0,
Value => 0, MaxValue => 0, Durability => 0,
RepairMaterial => Null_Unbounded_String, RepairSkill => 2,
Price => 0, InstallTime => 60, Unique => False, Size => 1,
Description => Null_Unbounded_String, MaxOwners => 1, Speed => 4,
Reputation => -100);
ModuleNode := Item(NodesList, I);
ModuleIndex :=
To_Unbounded_String(Get_Attribute(ModuleNode, "index"));
Action :=
(if Get_Attribute(ModuleNode, "action")'Length > 0 then
Data_Action'Value(Get_Attribute(ModuleNode, "action"))
else ADD);
if Action in UPDATE | REMOVE then
if not BaseModules_Container.Contains
(Modules_List, ModuleIndex) then
raise Data_Loading_Error
with "Can't " & To_Lower(Data_Action'Image(Action)) &
" ship module '" & To_String(ModuleIndex) &
"', there is no ship module with that index.";
end if;
elsif BaseModules_Container.Contains(Modules_List, ModuleIndex) then
raise Data_Loading_Error
with "Can't add ship module '" & To_String(ModuleIndex) &
"', there is already a ship with that index.";
end if;
if Action /= REMOVE then
if Action = UPDATE then
TempRecord := Modules_List(ModuleIndex);
end if;
if Get_Attribute(ModuleNode, "name")'Length > 0 then
TempRecord.Name :=
To_Unbounded_String(Get_Attribute(ModuleNode, "name"));
end if;
if Get_Attribute(ModuleNode, "type")'Length > 0 then
TempRecord.MType :=
ModuleType'Value(Get_Attribute(ModuleNode, "type"));
end if;
if Get_Attribute(ModuleNode, "weight")'Length > 0 then
TempRecord.Weight :=
Natural'Value(Get_Attribute(ModuleNode, "weight"));
end if;
if Get_Attribute(ModuleNode, "value")'Length > 0 then
TempRecord.Value :=
Integer'Value(Get_Attribute(ModuleNode, "value"));
end if;
if Get_Attribute(ModuleNode, "maxvalue")'Length > 0 then
TempRecord.MaxValue :=
Integer'Value(Get_Attribute(ModuleNode, "maxvalue"));
end if;
if Get_Attribute(ModuleNode, "durability")'Length > 0 then
TempRecord.Durability :=
Integer'Value(Get_Attribute(ModuleNode, "durability"));
end if;
if Get_Attribute(ModuleNode, "material")'Length > 0 then
TempRecord.RepairMaterial :=
To_Unbounded_String(Get_Attribute(ModuleNode, "material"));
MaterialExists := False;
Check_Materials_Loop :
for Material of Items_Types loop
if Material = TempRecord.RepairMaterial then
MaterialExists := True;
exit Check_Materials_Loop;
end if;
end loop Check_Materials_Loop;
if not MaterialExists then
raise Data_Loading_Error
with "Can't " & To_Lower(Data_Action'Image(Action)) &
" ship module '" & To_String(ModuleIndex) &
"', there is no item type '" &
Get_Attribute(ModuleNode, "material") & "'.";
end if;
end if;
if Get_Attribute(ModuleNode, "skill")'Length > 0 then
SkillIndex :=
Find_Skill_Index(Get_Attribute(ModuleNode, "skill"));
if SkillIndex = 0 then
raise Data_Loading_Error
with "Can't " & To_Lower(Data_Action'Image(Action)) &
" ship module '" & To_String(ModuleIndex) &
"', there is no skill named '" &
Get_Attribute(ModuleNode, "skill") & "'.";
end if;
TempRecord.RepairSkill := SkillIndex;
end if;
if Get_Attribute(ModuleNode, "price")'Length > 0 then
TempRecord.Price :=
Integer'Value(Get_Attribute(ModuleNode, "price"));
end if;
if Get_Attribute(ModuleNode, "installtime")'Length > 0 then
TempRecord.InstallTime :=
Positive'Value(Get_Attribute(ModuleNode, "installtime"));
end if;
if Get_Attribute(ModuleNode, "unique") /= "" then
TempRecord.Unique := True;
end if;
if Get_Attribute(ModuleNode, "size") /= "" then
TempRecord.Size :=
Integer'Value(Get_Attribute(ModuleNode, "size"));
end if;
if Get_Attribute(ModuleNode, "maxowners")'Length > 0 then
TempRecord.MaxOwners :=
Integer'Value(Get_Attribute(ModuleNode, "maxowners"));
end if;
if Get_Attribute(ModuleNode, "speed")'Length > 0 then
TempRecord.Speed :=
Integer'Value(Get_Attribute(ModuleNode, "speed"));
end if;
if Get_Attribute(ModuleNode, "reputation")'Length > 0 then
TempRecord.Reputation :=
Integer'Value(Get_Attribute(ModuleNode, "reputation"));
end if;
if Has_Child_Nodes(ModuleNode) then
TempRecord.Description :=
To_Unbounded_String(Node_Value(First_Child(ModuleNode)));
end if;
if Action /= UPDATE then
BaseModules_Container.Include
(Modules_List, ModuleIndex, TempRecord);
Log_Message
("Module added: " & To_String(TempRecord.Name), EVERYTHING);
else
Modules_List(ModuleIndex) := TempRecord;
Log_Message
("Module updated: " & To_String(TempRecord.Name), EVERYTHING);
end if;
else
BaseModules_Container.Exclude(Modules_List, ModuleIndex);
Log_Message
("Module removed: " & To_String(ModuleIndex), EVERYTHING);
end if;
end loop Load_Modules_Loop;
end LoadShipModules;
function GetModuleType(ModuleIndex: Unbounded_String) return String is
ModuleTypeName: Unbounded_String :=
To_Unbounded_String
(To_Lower(ModuleType'Image(Modules_List(ModuleIndex).MType)));
begin
Replace_Element
(ModuleTypeName, 1,
To_Upper(Ada.Strings.Unbounded.Element(ModuleTypeName, 1)));
Translate(ModuleTypeName, To_Mapping("_", " "));
return To_String(ModuleTypeName);
end GetModuleType;
end ShipModules;
|
oeis/171/A171814.asm | neoneye/loda-programs | 11 | 168908 | ; A171814: Triangle T : T(n,k)= A007318(n,k)*A001700(n-k).
; Submitted by <NAME>
; 1,3,1,10,6,1,35,30,9,1,126,140,60,12,1,462,630,350,100,15,1,1716,2772,1890,700,150,18,1,6435,12012,9702,4410,1225,210,21,1,24310,51480,48048,25872,8820,1960,280,24,1
lpb $0
add $1,1
sub $0,$1
mov $2,$1
sub $2,$0
lpe
bin $1,$0
mov $0,2
add $2,1
mul $0,$2
bin $0,$2
mul $1,16
mul $1,$0
mov $0,$1
div $0,32
|
osmake/bootsect.asm | archibate/Lake-OS | 1 | 97889 | <filename>osmake/bootsect.asm
; vim: ft=nasm ai
FDMEM0 equ 0x8000
HEADOFF equ 0x4400
DRV_NR equ 0x00
NCYLS equ 10
SAVCYLS equ 0xff0
org 0x7c00
_start:
jmp entry
DB 0x90
DB "lake-ipl" ; freeparam 启动区的名称可以是任意的字符串（8字节）
DW 512 ; 每个扇区（sector）的大小（必须为512字节）
DB 1 ; 簇（cluster）的大小（必须为1个扇区）
DW 1 ; FAT的起始位置（一般从第一个扇区开始）
DB 2 ; FAT的个数（必须为2）
DW 224 ; 根目录的大小（一般设成224项）
DW 2880 ; 该磁盘的大小（必须是2880扇区）
DB 0xf0 ; 磁盘的种类（必须是0xf0）
DW 9 ; FAT的长度（必须是9扇区）
DW 18 ; 1个磁道（track）有几个扇区（必须是18）
DW 2 ; 磁头数（必须是2）
DD 0 ; 不使用分区，必须是0
DD 2880 ; 重写一次磁盘大小
DB 0x00 ; int13h 所用的驱动器号（A软盘为0x00)
DB 0x00 ; 未使用
DB 0x29 ; 扩展引导标记
DD 0xffffffff ; 卷序列号
DB "LAKE-OS FDA" ; 卷标（11字节）
DB "FAT12 " ; 磁盘格式（8字节）
RESB 18 ; 先空出18字节
entry:
xor ax, ax
mov ds, ax
mov es, ax
mov ss, ax
mov sp, _start
mov si, msg_load
call print
readdisk:
mov ax, FDMEM0 >> 4
mov es, ax
mov ch, 0 ; cyln
mov dh, 0 ; head
mov cl, 1 ; sect
.loop:
mov si, 5 ; max_fail_time
.retry:
mov ah, 0x02
mov al, 1
xor bx, bx
mov dl, DRV_NR
int 0x13
jnc .next
dec si
jz error
mov ah, 0x00
mov dl, DRV_NR
int 0x13
jmp .retry
.next:
mov ax, es
add ax, 0x0020
mov es, ax
inc cl
cmp cl, 18
jbe .loop
mov cl, 1
inc dh
cmp dh, 2
jb .loop
mov dh, 0
call putdot
inc ch
cmp ch, NCYLS
jb .loop
.readok:
mov [SAVCYLS], ch
mov si, msg_ok
call print
jmp FDMEM0 + HEADOFF
error:
mov si, msg_err
call print
.waitkey:
mov ah, 0
int 0x16
.reset:
int 0x19
halt:
hlt
jmp halt
putdot:
mov ah, 0x0e
mov al, '.'
int 0x10
ret
print:
mov ah, 0x0e
.loop:
lodsb
test al, al
jz .fin
int 0x10
jmp .loop
.fin:
ret
msg_load:
db 13, 10, 10
db "Loading System"
db 0
msg_ok:
db "done"
db 13, 10
db "Booting kernel..."
db 0
msg_err:
db 13, 10
db "Error Occurred"
db 13, 10
db "press any key to reset"
db 13, 0
resb $$ + 510 - $
db 0x55, 0xaa
|
programs/oeis/213/A213498.asm | neoneye/loda | 22 | 247055 | ; A213498: Number of (w,x,y) with all terms in {0,...,n} and w != max(|w-x|,|x-y|,|y-w|)
; 0,4,15,43,88,164,267,415,600,844,1135,1499,1920,2428,3003,3679,4432,5300,6255,7339,8520,9844,11275,12863,14568,16444,18447,20635,22960,25484,28155,31039,34080,37348,40783,44459,48312,52420,56715,61279,66040,71084,76335,81883,87648,93724,100027,106655,113520,120724,128175,135979,144040,152468,161163,170239,179592,189340,199375,209819,220560,231724,243195,255103,267328,280004,293007,306475,320280,334564,349195,364319,379800,395788,412143,429019,446272,464060,482235,500959,520080,539764,559855,580523,601608,623284,645387,668095,691240,715004,739215,764059,789360,815308,841723,868799,896352,924580,953295,982699
mov $1,$0
add $0,1
div $0,2
pow $0,2
add $0,$1
mov $2,$1
mul $2,$1
add $0,$2
mul $2,$1
add $0,$2
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_1705.asm | ljhsiun2/medusa | 9 | 175721 | .global s_prepare_buffers
s_prepare_buffers:
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x10e72, %rsi
lea addresses_normal_ht+0x11972, %rdi
nop
nop
nop
nop
nop
xor %rdx, %rdx
mov $103, %rcx
rep movsl
xor %rbx, %rbx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %r15
push %rax
push %rbx
push %rdx
// Store
lea addresses_WT+0x2f02, %rdx
nop
nop
nop
nop
sub $49349, %r10
mov $0x5152535455565758, %rax
movq %rax, %xmm2
movups %xmm2, (%rdx)
// Exception!!!
nop
mov (0), %rax
nop
nop
nop
nop
inc %rdx
// Faulty Load
lea addresses_PSE+0xc272, %rdx
nop
nop
nop
dec %rbx
mov (%rdx), %r14w
lea oracles, %rdx
and $0xff, %r14
shlq $12, %r14
mov (%rdx,%r14,1), %r14
pop %rdx
pop %rbx
pop %rax
pop %r15
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 4}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'same': False, 'congruent': 10, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_normal_ht'}}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
|
src/gen/gstreamer-gst_low_level-gstreamer_0_10_gst_audio_gstbaseaudiosink_h.ads | persan/A-gst | 1 | 13315 | <reponame>persan/A-gst<gh_stars>1-10
pragma Ada_2005;
pragma Style_Checks (Off);
pragma Warnings (Off);
with Interfaces.C; use Interfaces.C;
with glib;
with glib.Values;
with System;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_base_gstbasesink_h;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_audio_gstringbuffer_h;
with GLIB; -- with GStreamer.GST_Low_Level.glibconfig_h;
with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h;
with System;
limited with GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h;
with glib;
package GStreamer.GST_Low_Level.gstreamer_0_10_gst_audio_gstbaseaudiosink_h is
-- unsupported macro: GST_TYPE_BASE_AUDIO_SINK (gst_base_audio_sink_get_type())
-- arg-macro: function GST_BASE_AUDIO_SINK (obj)
-- return G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_BASE_AUDIO_SINK,GstBaseAudioSink);
-- arg-macro: function GST_BASE_AUDIO_SINK_CLASS (klass)
-- return G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_BASE_AUDIO_SINK,GstBaseAudioSinkClass);
-- arg-macro: function GST_BASE_AUDIO_SINK_GET_CLASS (obj)
-- return G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_BASE_AUDIO_SINK, GstBaseAudioSinkClass);
-- arg-macro: function GST_IS_BASE_AUDIO_SINK (obj)
-- return G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_BASE_AUDIO_SINK);
-- arg-macro: function GST_IS_BASE_AUDIO_SINK_CLASS (klass)
-- return G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_BASE_AUDIO_SINK);
-- arg-macro: function GST_BASE_AUDIO_SINK_CLOCK (obj)
-- return GST_BASE_AUDIO_SINK (obj).clock;
-- arg-macro: function GST_BASE_AUDIO_SINK_PAD (obj)
-- return GST_BASE_SINK (obj).sinkpad;
-- unsupported macro: GST_TYPE_BASE_AUDIO_SINK_SLAVE_METHOD (gst_base_audio_sink_slave_method_get_type ())
-- GStreamer
-- * Copyright (C) 1999,2000 <NAME> <<EMAIL>>
-- * 2005 <NAME> <<EMAIL>>
-- *
-- * gstbaseaudiosink.h:
-- *
-- * This library is free software; you can redistribute it and/or
-- * modify it under the terms of the GNU Library General Public
-- * License as published by the Free Software Foundation; either
-- * version 2 of the License, or (at your option) any later version.
-- *
-- * This library is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- * Library General Public License for more details.
-- *
-- * You should have received a copy of the GNU Library General Public
-- * License along with this library; if not, write to the
-- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- * Boston, MA 02111-1307, USA.
--
-- a base class for audio sinks.
-- *
-- * It uses a ringbuffer to schedule playback of samples. This makes
-- * it very easy to drop or insert samples to align incoming
-- * buffers to the exact playback timestamp.
-- *
-- * Subclasses must provide a ringbuffer pointing to either DMA
-- * memory or regular memory. A subclass should also call a callback
-- * function when it has played N segments in the buffer. The subclass
-- * is free to use a thread to signal this callback, use EIO or any
-- * other mechanism.
-- *
-- * The base class is able to operate in push or pull mode. The chain
-- * mode will queue the samples in the ringbuffer as much as possible.
-- * The available space is calculated in the callback function.
-- *
-- * The pull mode will pull_range() a new buffer of N samples with a
-- * configurable latency. This allows for high-end real time
-- * audio processing pipelines driven by the audiosink. The callback
-- * function will be used to perform a pull_range() on the sinkpad.
-- * The thread scheduling the callback can be a real-time thread.
-- *
-- * Subclasses must implement a GstRingBuffer in addition to overriding
-- * the methods in GstBaseSink and this class.
--
--*
-- * GST_BASE_AUDIO_SINK_CLOCK:
-- * @obj: a #GstBaseAudioSink
-- *
-- * Get the #GstClock of @obj.
--
--*
-- * GST_BASE_AUDIO_SINK_PAD:
-- * @obj: a #GstBaseAudioSink
-- *
-- * Get the sink #GstPad of @obj.
--
--*
-- * GstBaseAudioSinkSlaveMethod:
-- * @GST_BASE_AUDIO_SINK_SLAVE_RESAMPLE: Resample to match the master clock
-- * @GST_BASE_AUDIO_SINK_SLAVE_SKEW: Adjust playout pointer when master clock
-- * drifts too much.
-- * @GST_BASE_AUDIO_SINK_SLAVE_NONE: No adjustment is done.
-- *
-- * Different possible clock slaving algorithms used when the internal audio
-- * clock is not selected as the pipeline master clock.
--
type GstBaseAudioSinkSlaveMethod is
(GST_BASE_AUDIO_SINK_SLAVE_RESAMPLE,
GST_BASE_AUDIO_SINK_SLAVE_SKEW,
GST_BASE_AUDIO_SINK_SLAVE_NONE);
pragma Convention (C, GstBaseAudioSinkSlaveMethod); -- gst/audio/gstbaseaudiosink.h:96
type GstBaseAudioSink;
type anon_355;
type anon_356 is record
eos_rendering : aliased GLIB.gboolean; -- gst/audio/gstbaseaudiosink.h:134
end record;
pragma Convention (C_Pass_By_Copy, anon_356);
type u_GstBaseAudioSink_u_gst_reserved_array is array (0 .. 2) of System.Address;
type anon_355 (discr : unsigned := 0) is record
case discr is
when 0 =>
ABI : aliased anon_356; -- gst/audio/gstbaseaudiosink.h:135
when others =>
u_gst_reserved : u_GstBaseAudioSink_u_gst_reserved_array; -- gst/audio/gstbaseaudiosink.h:136
end case;
end record;
pragma Convention (C_Pass_By_Copy, anon_355);
pragma Unchecked_Union (anon_355);--subtype GstBaseAudioSink is u_GstBaseAudioSink; -- gst/audio/gstbaseaudiosink.h:100
type GstBaseAudioSinkClass;
type u_GstBaseAudioSinkClass_u_gst_reserved_array is array (0 .. 2) of System.Address;
--subtype GstBaseAudioSinkClass is u_GstBaseAudioSinkClass; -- gst/audio/gstbaseaudiosink.h:101
-- skipped empty struct u_GstBaseAudioSinkPrivate
-- skipped empty struct GstBaseAudioSinkPrivate
--*
-- * GstBaseAudioSink:
-- *
-- * Opaque #GstBaseAudioSink.
--
type GstBaseAudioSink is record
element : aliased GStreamer.GST_Low_Level.gstreamer_0_10_gst_base_gstbasesink_h.GstBaseSink; -- gst/audio/gstbaseaudiosink.h:110
ringbuffer : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_audio_gstringbuffer_h.GstRingBuffer; -- gst/audio/gstbaseaudiosink.h:114
buffer_time : aliased GLIB.guint64; -- gst/audio/gstbaseaudiosink.h:117
latency_time : aliased GLIB.guint64; -- gst/audio/gstbaseaudiosink.h:118
next_sample : aliased GLIB.guint64; -- gst/audio/gstbaseaudiosink.h:121
provide_clock : aliased GLIB.gboolean; -- gst/audio/gstbaseaudiosink.h:124
provided_clock : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h.GstClock; -- gst/audio/gstbaseaudiosink.h:125
priv : System.Address; -- gst/audio/gstbaseaudiosink.h:128
abidata : aliased anon_355; -- gst/audio/gstbaseaudiosink.h:137
end record;
pragma Convention (C_Pass_By_Copy, GstBaseAudioSink); -- gst/audio/gstbaseaudiosink.h:109
--< protected >
-- with LOCK
-- our ringbuffer
-- required buffer and latency in microseconds
-- the next sample to write
-- clock
--< private >
--< protected >
-- with g_atomic_; currently rendering eos
--*
-- * GstBaseAudioSinkClass:
-- * @parent_class: the parent class.
-- * @create_ringbuffer: create and return a #GstRingBuffer to write to.
-- * @payload: payload data in a format suitable to write to the sink. If no
-- * payloading is required, returns a reffed copy of the original
-- * buffer, else returns the payloaded buffer with all other metadata
-- * copied. (Since: 0.10.36)
-- *
-- * #GstBaseAudioSink class. Override the vmethod to implement
-- * functionality.
--
type GstBaseAudioSinkClass is record
parent_class : aliased GStreamer.GST_Low_Level.gstreamer_0_10_gst_base_gstbasesink_h.GstBaseSinkClass; -- gst/audio/gstbaseaudiosink.h:153
create_ringbuffer : access function (arg1 : access GstBaseAudioSink) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_audio_gstringbuffer_h.GstRingBuffer; -- gst/audio/gstbaseaudiosink.h:156
payload : access function (arg1 : access GstBaseAudioSink; arg2 : access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h.GstBuffer) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstbuffer_h.GstBuffer; -- gst/audio/gstbaseaudiosink.h:160
u_gst_reserved : u_GstBaseAudioSinkClass_u_gst_reserved_array; -- gst/audio/gstbaseaudiosink.h:163
end record;
pragma Convention (C_Pass_By_Copy, GstBaseAudioSinkClass); -- gst/audio/gstbaseaudiosink.h:152
-- subclass ringbuffer allocation
-- subclass payloader
--< private >
function gst_base_audio_sink_get_type return GLIB.GType; -- gst/audio/gstbaseaudiosink.h:166
pragma Import (C, gst_base_audio_sink_get_type, "gst_base_audio_sink_get_type");
function gst_base_audio_sink_slave_method_get_type return GLIB.GType; -- gst/audio/gstbaseaudiosink.h:167
pragma Import (C, gst_base_audio_sink_slave_method_get_type, "gst_base_audio_sink_slave_method_get_type");
function gst_base_audio_sink_create_ringbuffer (sink : access GstBaseAudioSink) return access GStreamer.GST_Low_Level.gstreamer_0_10_gst_audio_gstringbuffer_h.GstRingBuffer; -- gst/audio/gstbaseaudiosink.h:169
pragma Import (C, gst_base_audio_sink_create_ringbuffer, "gst_base_audio_sink_create_ringbuffer");
procedure gst_base_audio_sink_set_provide_clock (sink : access GstBaseAudioSink; provide : GLIB.gboolean); -- gst/audio/gstbaseaudiosink.h:171
pragma Import (C, gst_base_audio_sink_set_provide_clock, "gst_base_audio_sink_set_provide_clock");
function gst_base_audio_sink_get_provide_clock (sink : access GstBaseAudioSink) return GLIB.gboolean; -- gst/audio/gstbaseaudiosink.h:172
pragma Import (C, gst_base_audio_sink_get_provide_clock, "gst_base_audio_sink_get_provide_clock");
procedure gst_base_audio_sink_set_slave_method (sink : access GstBaseAudioSink; method : GstBaseAudioSinkSlaveMethod); -- gst/audio/gstbaseaudiosink.h:174
pragma Import (C, gst_base_audio_sink_set_slave_method, "gst_base_audio_sink_set_slave_method");
function gst_base_audio_sink_get_slave_method (sink : access GstBaseAudioSink) return GstBaseAudioSinkSlaveMethod; -- gst/audio/gstbaseaudiosink.h:177
pragma Import (C, gst_base_audio_sink_get_slave_method, "gst_base_audio_sink_get_slave_method");
procedure gst_base_audio_sink_set_drift_tolerance (sink : access GstBaseAudioSink; drift_tolerance : GLIB.gint64); -- gst/audio/gstbaseaudiosink.h:179
pragma Import (C, gst_base_audio_sink_set_drift_tolerance, "gst_base_audio_sink_set_drift_tolerance");
function gst_base_audio_sink_get_drift_tolerance (sink : access GstBaseAudioSink) return GLIB.gint64; -- gst/audio/gstbaseaudiosink.h:181
pragma Import (C, gst_base_audio_sink_get_drift_tolerance, "gst_base_audio_sink_get_drift_tolerance");
procedure gst_base_audio_sink_set_alignment_threshold (sink : access GstBaseAudioSink; alignment_threshold : GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h.GstClockTime); -- gst/audio/gstbaseaudiosink.h:183
pragma Import (C, gst_base_audio_sink_set_alignment_threshold, "gst_base_audio_sink_set_alignment_threshold");
function gst_base_audio_sink_get_alignment_threshold (sink : access GstBaseAudioSink) return GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h.GstClockTime; -- gst/audio/gstbaseaudiosink.h:186
pragma Import (C, gst_base_audio_sink_get_alignment_threshold, "gst_base_audio_sink_get_alignment_threshold");
procedure gst_base_audio_sink_set_discont_wait (sink : access GstBaseAudioSink; discont_wait : GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h.GstClockTime); -- gst/audio/gstbaseaudiosink.h:188
pragma Import (C, gst_base_audio_sink_set_discont_wait, "gst_base_audio_sink_set_discont_wait");
function gst_base_audio_sink_get_discont_wait (sink : access GstBaseAudioSink) return GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstclock_h.GstClockTime; -- gst/audio/gstbaseaudiosink.h:191
pragma Import (C, gst_base_audio_sink_get_discont_wait, "gst_base_audio_sink_get_discont_wait");
end GStreamer.GST_Low_Level.gstreamer_0_10_gst_audio_gstbaseaudiosink_h;
|
languages/dynlink/ada-interfaces/pkg.adb | sergev/vak-opensource | 34 | 15004 | with System;
use System;
package body Pkg is
function "=" (x, y: Arithmetic) return Boolean is
begin
return (x'Address = y'Address);
end "=";
function Type_Name (x: Arithmetic) return String is
begin
return "PKG.ARITHMETIC";
end Type_Name;
function Cast (x: in Arithmetic; iface: String) return System.Address is
begin
if iface = "PKG.SEQUENCE" then
return Sequence(x)'Address;
end if;
if iface = "PKG.PRINTABLE" then
return Printable(x)'Address;
end if;
if iface = "PKG.ARITHMETIC" then
return Arithmetic(x)'Address;
end if;
return Null_Address;
end Cast;
function Value (n: Arithmetic) return Integer is
begin
return n.val;
end Value;
procedure Next (n: in out Arithmetic) is
begin
n.val := n.val + 1;
end Next;
procedure Print (n: Arithmetic) is
begin
return;
end Print;
end Pkg;
|
programs/oeis/034/A034721.asm | karttu/loda | 0 | 86259 | <reponame>karttu/loda
; A034721: a(n) = (10*n^3 - 9*n^2 + 2*n)/3 + 1.
; 1,2,17,66,169,346,617,1002,1521,2194,3041,4082,5337,6826,8569,10586,12897,15522,18481,21794,25481,29562,34057,38986,44369,50226,56577,63442,70841,78794,87321,96442,106177,116546,127569,139266,151657,164762,178601,193194,208561,224722,241697,259506,278169,297706,318137,339482,361761,384994,409201,434402,460617,487866,516169,545546,576017,607602,640321,674194,709241,745482,782937,821626,861569,902786,945297,989122,1034281,1080794,1128681,1177962,1228657,1280786,1334369,1389426,1445977,1504042,1563641,1624794,1687521,1751842,1817777,1885346,1954569,2025466,2098057,2172362,2248401,2326194,2405761,2487122,2570297,2655306,2742169,2830906,2921537,3014082,3108561,3204994,3303401,3403802,3506217,3610666,3717169,3825746,3936417,4049202,4164121,4281194,4400441,4521882,4645537,4771426,4899569,5029986,5162697,5297722,5435081,5574794,5716881,5861362,6008257,6157586,6309369,6463626,6620377,6779642,6941441,7105794,7272721,7442242,7614377,7789146,7966569,8146666,8329457,8514962,8703201,8894194,9087961,9284522,9483897,9686106,9891169,10099106,10309937,10523682,10740361,10959994,11182601,11408202,11636817,11868466,12103169,12340946,12581817,12825802,13072921,13323194,13576641,13833282,14093137,14356226,14622569,14892186,15165097,15441322,15720881,16003794,16290081,16579762,16872857,17169386,17469369,17772826,18079777,18390242,18704241,19021794,19342921,19667642,19995977,20327946,20663569,21002866,21345857,21692562,22043001,22397194,22755161,23116922,23482497,23851906,24225169,24602306,24983337,25368282,25757161,26149994,26546801,26947602,27352417,27761266,28174169,28591146,29012217,29437402,29866721,30300194,30737841,31179682,31625737,32076026,32530569,32989386,33452497,33919922,34391681,34867794,35348281,35833162,36322457,36816186,37314369,37817026,38324177,38835842,39352041,39872794,40398121,40928042,41462577,42001746,42545569,43094066,43647257,44205162,44767801,45335194,45907361,46484322,47066097,47652706,48244169,48840506,49441737,50047882,50658961,51274994
mov $1,1
mov $2,4
mov $3,$0
mov $4,$0
lpb $0,1
sub $0,1
add $1,$4
add $3,$2
mov $2,6
add $3,6
add $4,$3
add $3,5
lpe
|
oeis/322/A322242.asm | neoneye/loda-programs | 11 | 11766 | ; A322242: G.f.: 1/sqrt(1 - 6*x - 7*x^2).
; Submitted by <NAME>
; 1,3,17,99,609,3843,24689,160611,1054657,6975747,46406097,310171491,2081258529,14011445763,94594402353,640188979299,4341874207617,29502747778563,200803974858641,1368767759442531,9342637825548769,63846282803069187,436797192815981553,2991302112253485411,20504081077963103041,140665546932766467843,965770879590646638929,6635507385062085656931,45621050527781298148257,313853761645612785245187,2160439635613768883749809,14879669137512851310571107,102533527122441148295988993,706881323505421291251084291
mov $1,1
mov $2,1
mov $3,$0
mov $4,1
lpb $3
mul $1,$4
mul $1,$3
mul $1,4
mul $2,-2
add $5,$4
div $1,$5
div $2,2
add $2,$1
sub $3,1
add $4,2
lpe
mov $0,$2
|
physical_memory/memory.adb | SMerrony/dgemua | 2 | 21275 | <filename>physical_memory/memory.adb
-- MIT License
-- Copyright (c) 2021 <NAME>
-- Permission is hereby granted, free of charge, to any person obtaining a copy
-- of this software and associated documentation files (the "Software"), to deal
-- in the Software without restriction, including without limitation the rights
-- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-- copies of the Software, and to permit persons to whom the Software is
-- furnished to do so, subject to the following conditions:
-- The above copyright notice and this permission notice shall be included in all
-- copies or substantial portions of the Software.
-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-- SOFTWARE.
with Ada.Text_IO; use Ada.Text_IO;
-- with Ada.Strings; use Ada.Strings;
-- with Ada.Strings.Fixed; use Ada.Strings.Fixed;
-- with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Debug_Logs; use Debug_Logs;
with Memory_Channels; use Memory_Channels;
package body Memory is
protected body RAM is
procedure Init (Debug_Logging : in Boolean) is
begin
Is_Logging := Debug_Logging;
ATU_Enabled := False;
for W in RAM'Range loop
RAM (W) := 0;
end loop;
BMC_DCH.Init (Debug_Logging);
Put_Line
("INFO: Initialised " & Integer'Image (RAM'Length) &
" words of main memory");
end Init;
function Read_Byte
(Word_Addr : in Phys_Addr_T; Low_Byte : in Boolean) return Byte_T
is
W : Word_T;
begin
W := RAM (Word_Addr); -- *** DIRECT ACCESS TO RAM ***
if not Low_Byte then
W := Shift_Right (W, 8);
end if;
return Byte_T (W and 16#00ff#);
end Read_Byte;
function Read_Byte_BA (BA : in Dword_T) return Byte_T is
LB : Boolean := Test_DW_Bit (BA, 31);
begin
return Read_Byte (Phys_Addr_T(Shift_Right(BA, 1)), LB);
end Read_Byte_BA;
function Read_Bytes_BA (BA : in Dword_T; Num : in Natural) return Byte_Arr_T is
Bytes : Byte_Arr_T (0 .. Num);
begin
for B in 0 .. Num - 1 loop
Bytes(B) := Read_Byte_BA (BA + Dword_T(B));
end loop;
return Bytes;
end Read_Bytes_BA;
procedure Write_Byte (Word_Addr : in Phys_Addr_T; Low_Byte : in Boolean; Byt : in Byte_T) is
Wd : Word_T := Read_Word(Word_Addr);
begin
if Low_Byte then
Wd := (Wd and 16#ff00#) or Word_T(Byt);
else
Wd := Shift_Left(Word_T(Byt), 8) or (Wd and 16#00ff#);
end if;
Write_Word(Word_Addr, Wd);
end Write_Byte;
procedure Write_Byte_BA (BA : in Dword_T; Datum : in Byte_T) is
LB : Boolean := Test_DW_Bit (BA, 31);
begin
Write_Byte (Phys_Addr_T(Shift_Right(BA, 1)), LB, Datum);
end Write_Byte_BA;
procedure Copy_Byte_BA (Src, Dest : in Dword_T) is
Src_LB : Boolean := Test_DW_Bit (Src, 31);
Dest_LB : Boolean := Test_DW_Bit (Dest, 31);
Byt : Byte_T;
begin
Byt := Read_Byte (Phys_Addr_T(Shift_Right(Src, 1)), Src_LB);
Write_Byte (Phys_Addr_T(Shift_Right(Dest, 1)), Dest_LB, Byt);
end Copy_Byte_BA;
function Read_Byte_Eclipse_BA (Segment : in Phys_Addr_T; BA_16 : in Word_T) return Byte_T is
Low_Byte : Boolean := Test_W_Bit(BA_16, 15);
Addr : Phys_Addr_T;
begin
Addr := Shift_Right(Phys_Addr_T(BA_16), 1) or Segment;
return Read_Byte(Addr, Low_Byte);
end Read_Byte_Eclipse_BA;
procedure Write_Byte_Eclipse_BA (Segment : in Phys_Addr_T; BA_16 : in Word_T; Datum : in Byte_T) is
Low_Byte : Boolean := Test_W_Bit(BA_16, 15);
Addr : Phys_Addr_T;
begin
Addr := Shift_Right(Phys_Addr_T(BA_16), 1) or Segment;
Write_Byte (Addr, Low_Byte, Datum);
end Write_Byte_Eclipse_BA;
function Read_Dword (Word_Addr : in Phys_Addr_T) return Dword_T is
(Dword_From_Two_Words(RAM (Word_Addr), RAM (Word_Addr + 1))); -- *** Direct RAM Access ***
procedure Write_Dword (Word_Addr : in Phys_Addr_T; Datum : Dword_T) is
begin
Write_Word (Word_Addr, Upper_Word (Datum));
Write_Word (Word_Addr + 1, DG_Types.Lower_Word (Datum));
end Write_Dword;
function Read_Word (Word_Addr : in Phys_Addr_T) return Word_T is
(RAM (Word_Addr));
function Read_Qword (Word_Addr : in Phys_Addr_T) return Qword_T is
DW_L, DW_R : Dword_T;
begin
DW_L := Read_Dword (Word_Addr);
DW_R := Read_Dword (Word_Addr + 2);
return Shift_Left(Qword_T(DW_L), 32) or Qword_T(DW_R);
end Read_Qword;
procedure Write_Word (Word_Addr : in Phys_Addr_T; Datum : Word_T) is
-- FOR THE MOMENT _ALL_ MEMORY WRITES ARE VIA THIS PROC
begin
-- -- DEBUGGING
-- if Word_Addr = 2 then
-- Put_Line ("Writing to Location 2, VALUE: " & Datum'Image);
-- end if;
-- if Word_Addr = 0 then
-- Put_Line ("Writing to Location 0, VALUE: " & Datum'Image);
-- end if;
RAM (Word_Addr) := Datum;
end Write_Word;
procedure Write_Qword (Word_Addr : in Phys_Addr_T; Datum : Qword_T) is
begin
Write_Dword(Word_Addr, Dword_T(Shift_Right(Datum, 32)));
Write_Dword(Word_Addr + 2, Dword_T(Datum and 16#0000_ffff#));
end Write_Qword;
end RAM;
protected body Narrow_Stack is
procedure Push (Segment : in Phys_Addr_T; Datum : in Word_T) is
New_NSP : Word_T := RAM.Read_Word (NSP_Loc or Segment) + 1;
begin
RAM.Write_Word (NSP_Loc or Segment, New_NSP);
RAM.Write_Word (Phys_Addr_T (New_NSP) or Segment, Datum);
end Push;
function Pop (Segment : in Phys_Addr_T) return Word_T is
Old_NSP : Word_T := RAM.Read_Word (NSP_Loc or Segment);
Datum : Word_T := RAM.Read_Word (Phys_Addr_T (Old_NSP) or Segment);
begin
RAM.Write_Word (NSP_Loc or Segment, Old_NSP - 1);
return Datum;
end Pop;
end Narrow_Stack;
end Memory;
|
tests/tk-test_data-tests.adb | thindil/tashy2 | 2 | 29131 | <filename>tests/tk-test_data-tests.adb
-- This package has been generated automatically by GNATtest.
-- You are allowed to add your code to the bodies of test routines.
-- Such changes will be kept during further regeneration of this file.
-- All code placed outside of test routine bodies will be lost. The
-- code intended to set up and tear down the test environment should be
-- placed into Tk.Test_Data.
with AUnit.Assertions; use AUnit.Assertions;
with System.Assertions;
-- begin read only
-- id:2.2/00/
--
-- This section can be used to add with clauses if necessary.
--
-- end read only
with Ada.Environment_Variables; use Ada.Environment_Variables;
with Tcl.Info; use Tcl.Info;
-- begin read only
-- end read only
package body Tk.Test_Data.Tests is
-- begin read only
-- id:2.2/01/
--
-- This section can be used to add global variables and other elements.
--
-- end read only
-- begin read only
-- end read only
-- begin read only
procedure Wrap_Test_Tk_Init_dae4dd_f1b9f1
(Interpreter: Tcl_Interpreter := Get_Interpreter) is
begin
begin
pragma Assert(Interpreter /= Null_Interpreter);
null;
exception
when System.Assertions.Assert_Failure =>
AUnit.Assertions.Assert
(False,
"req_sloc(tk.ads:0):Test_Tk_Init test requirement violated");
end;
GNATtest_Generated.GNATtest_Standard.Tk.Tk_Init(Interpreter);
begin
pragma Assert(True);
null;
exception
when System.Assertions.Assert_Failure =>
AUnit.Assertions.Assert
(False,
"ens_sloc(tk.ads:0:):Test_Tk_Init test commitment violated");
end;
end Wrap_Test_Tk_Init_dae4dd_f1b9f1;
-- end read only
-- begin read only
procedure Test_Tk_Init_test_tk_init(Gnattest_T: in out Test);
procedure Test_Tk_Init_dae4dd_f1b9f1(Gnattest_T: in out Test) renames
Test_Tk_Init_test_tk_init;
-- id:2.2/dae4ddda1671ac5f/Tk_Init/1/0/test_tk_init/
procedure Test_Tk_Init_test_tk_init(Gnattest_T: in out Test) is
procedure Tk_Init
(Interpreter: Tcl_Interpreter := Get_Interpreter) renames
Wrap_Test_Tk_Init_dae4dd_f1b9f1;
-- end read only
pragma Unreferenced(Gnattest_T);
begin
if Value("DISPLAY", "")'Length = 0
or else Info.Exists("tk_version").Result then
Assert(True, "No display, can't test");
return;
end if;
Tk_Init;
Assert(True, "This test can only crash");
-- begin read only
end Test_Tk_Init_test_tk_init;
-- end read only
-- begin read only
-- id:2.2/02/
--
-- This section can be used to add elaboration code for the global state.
--
begin
-- end read only
null;
-- begin read only
-- end read only
end Tk.Test_Data.Tests;
|
programs/oeis/274/A274010.asm | neoneye/loda | 22 | 105153 | <reponame>neoneye/loda<filename>programs/oeis/274/A274010.asm
; A274010: Boris Stechkin function: a(n) is the number of m with 2 <= m <= n and floor(n(m-1)/m) divisible by m-1.
; 0,0,1,2,3,3,4,4,4,5,5,4,6,6,4,6,7,5,6,6,6,8,6,4,8,9,5,6,8,6,8,8,6,8,6,6,11,9,4,6,10,8,8,8,6,10,8,4,10,11,7,8,8,6,8,10,10,10,6,4,12,12,4,8,11,9,10,8,6,8,10,8,12,12,4,8,10,8,10,8,10,13,7,4,12,14,6,6,10,8,12,14,8,8,6,6,14,12,6,10
trn $0,1
seq $0,92338 ; a(n) = number of numbers d with n mod d <= 1.
sub $0,1
|
src/aim_arrow.asm | rondnelson99/bomb-golf | 1 | 7816 | INCLUDE "defines.asm"
ARROW_DIRECTION_INIT equ $FF ;an arrow direction of $ff indicates that the direction needs to be initialized
SECTION "Init Aim Arrow", ROM0
InitAimArrow::
ld hl, wArrowFacingDirection
xor a
ld [hl+], a ;facing up
ld [hl], ARROW_DIRECTION_INIT
ret
SECTION "Clear Arrow Sprite", ROM0
ClearArrowSprite::
xor a
ld [OBJ_ARROW], a ;zero the Y position
ret
SECTION "Check Aiming", ROM0
CheckAiming:: ;reads player input and adjusts the aiming direction if nescessary
ldh a, [hHeldKeys]
bit PADB_B, a
jr nz, UpdateAimArrow ;if they're holding B, then the camera moves instead
ldh a, [hPressedKeys]
ld b, a
ld hl, wArrowFacingDirection
bit PADB_LEFT, b
jr z, .notLeft
.left
ld a, [hl]
dec a ;move counterclockwise one direction
and $0f ;mod 16
ld [hl], a
jr UpdateAimArrow ;they can't press left and right at the same time, so we're done here
.notLeft
bit PADB_RIGHT, b
jr z, .notRight
.right
ld a, [hl]
inc a ;move clockwise one direction
and $0f ;mod 16
ld [hl], a
.notRight
UpdateAimArrow:: ;draws an arrow from the golf ball in whatever ditection it's facing
;check if the tile in VRAM needs updating
ld hl, wArrowFacingDirection
ld a, [hl+]
cp [hl] ;is the current direction equal to the old direction?
jr z, .doneUpdateTile
.updateTile ;if not, replce the arrow tile in VRAM
; a contains the desired arrow facing direction
ld [hl], a ; we're updating it, wo set wOldArrowDirection to the new one
swap a ; multiply by 16 to get the offset within the tile area
ld e, a ;low byte of the tile data pointer
ld d, HIGH(ArrowTiles)
assert LOW(ArrowTiles) == 0
; de now pints to the desired tile
ld hl, $8000 + SPRITE_ARROW * 16 ;pointer to the arrow location in VRAM
ld c, 16 ;copy 1 tile
call LCDMemcpySmall ;write the tile
.doneUpdateTile
ld a, [wArrowFacingDirection]
add a, a ;double it bc there are two bytes per entry
ld l, a
ld h, HIGH(ArrowPositionLUT)
assert LOW(ArrowPositionLUT) == 0
;now hl points to the the Y offset of the arrow, followed by X offset
ld b, [hl]
inc l
ld c, [hl]
ld hl, wBallY ;this is a 12.4 course-relative coordinate folloewd by the X coordinate
ld de, OBJ_ARROW ;shadow OAM entry
call RenderSprite124 ;render the sprite to shadow OAM
;now just write tile number and flags, which hl points to
ld a, SPRITE_ARROW ;tile number
ld [hl+], a
ld [hl], 0 ;no special flags
ret
MACRO ArrowPosition ;arguments are relative to the center of the arrow
db \1 - 4
db \2 - 4
ENDM
SECTION "Arrow Position Table", ROM0, ALIGN[8]
ArrowPositionLUT: ;table of Y and X offsets relative to the ball for each direction, plus the OAM offset
ArrowPosition -8, 0 ;up
ArrowPosition -8, 3
ArrowPosition -7, 5
ArrowPosition -3, 8
ArrowPosition 0, 8 ;right
ArrowPosition 3, 8
ArrowPosition 5, 5
ArrowPosition 7, 4
ArrowPosition 8, 0 ;down
ArrowPosition 8, -3
ArrowPosition 6, -6
ArrowPosition 3, -8
ArrowPosition 0, -8 ;left
ArrowPosition -3, -8
ArrowPosition -6, -6
ArrowPosition -8, -4
SECTION "Arrow Tiles", ROM0, ALIGN[8] ; the data is 256 bytes so alignment should be basically free
ArrowTiles:
INCBIN "res/arrows.2bpp" ;16 tiles, one for each direction 0 (straight up) clockwse to 15 (upwards angled left)
SECTION "Arrow Variables", WRAM0
wArrowFacingDirection:: ; This can be written to by other parts of the code to change the direction that the arrow is facing
db ;stores a direction from 0 (straight up) clockwse to 15 (upwards angled left)
wOldArrowDirection: ;this is used to ckeck if the direction has changed (and a new tile needs to be copied into VRAM)
db ;$FF indicates that the direction needs to be initialized |
roms/ICEBOX.asm | isene/hp-41_GEIR.ROM | 2 | 19819 | ;:LISTING GENERATED: 1/28/2018 18:14:13 by MLDL Manager version 1.70.0 by MLDL Manager version
;:OPEN FILE: Z:\home\geir\Dropbox\Cur\0_HP-41CL\4_GIT\hp-41_icebox\ICEBOX1H.ROM
LB_A2A5: .con 0x344 ; ST=0 12
.con 0x0A6 ; ACEX S&X
.con 0x05A ; C=0 M
.con 0x1BC ; RCR 11
.con 0x11A ; A=C M
.con 0x220 ; C=KEYS
.con 0x03C ; RCR 3
.con 0x106 ; A=C S&X
.con 0x1B0 ; C=STK
LB_A2AE: .con 0x330 ; CXISA
.con 0x23A ; C=C+1 M
.con 0x2E6 ; ?C#0 S&X
; .con 0x023 ; GONC +04 LB_A2B5 A2B5
gonc LB_A2B5
.con 0x366 ; ?A#C S&X
; .con 0x3DF ; GOC -05 LB_A2AE A2AE
goc LB_A2AE
.con 0x046 ; C=0 S&X
LB_A2B5: .con 0x21A ; C=A+C M
.con 0x34C ; ST=1? 12
; .con 0x017 ; GOC +02 LB_A2B9 A2B9
goc LB_A2B9
.con 0x1E0 ; GOTOC
LB_A2B9: .con 0x344 ; ST=0 12
.con 0x36D ; GOLNC 0FDB
.con 0x03E ;
.con 0x08E ;
.con 0x009 ;
.con 0x018 ;
.con 0x005 ;
.NAME "HEXIN"
HEXIN: .con 0x108 ; ST=1 8
.con 0x041 ; GSUBNC ARGOUT 2C10 ; HP41 SYSTEM ROM 2
.con 0x0B0 ;
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x04E ; C=0 ALL
.con 0x158 ; M=C
.con 0x070 ; N=C
LB_A2C9: .con 0x3DD ; GSUBNC LEFTJ 2BF7 ; HP41 SYSTEM ROM 2
.con 0x0AC ;
.con 0x261 ; GSUBNC RSTKB 0098 ; HP41 SYSTEM ROM 0
.con 0x000 ;
LB_A2CD: .con 0x3CC ; CHKKB
; .con 0x3FB ; GONC -01 LB_A2CD A2CD
gonc LB_A2CD
.con 0x130 ; LDI 013
.con 0x013 ;
.con 0x106 ; A=C S&X
; .con 0x379 ; GSB41C LB_A2A5 A2A5 ; GSUBNC 0FDE, address in same Quad
RXQ LB_A2A5
; .con 0x03C ;
; .con 0x2A5 ;
.con 0x011 ; GSUBNC 3004
.con 0x0C0 ;
.con 0x080 ; UNDEF080
.con 0x070 ; N=C
.con 0x030 ; ROMBLK
.con 0x010 ; LC 0
.con 0x084 ; ST=0 5
.con 0x074 ; UNDEF074
.con 0x034 ; UNDEF034
.con 0x085 ; GSUBC STDEV4 1D21 ; HP41 SYSTEM ROM 1
.con 0x075 ;
.con 0x035 ; GOLNC 210D
.con 0x086 ;
.con 0x076 ; ABEX XS
.con 0x036 ; B=0 XS
; .con 0x037 ; GOC +06 LB_A2EA A2EA
goc LB_A2EA
; .con 0x087 ; GOC +10 LB_A2F5 A2F5
goc LB_A2F5
.con 0x018 ; UNDEF018
; .con 0x0C3 ; GONC +18 LB_A2FF A2FF
gonc LB_A2FF
.con 0x000 ; NOP
.con 0x226 ; C=C+1 S&X
LB_A2EA: .con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
LB_A2F5: .con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
.con 0x226 ; C=C+1 S&X
; .con 0x15B ; GONC +2B LB_A323 A323
gonc LB_A323
; .con 0x033 ; GONC +06 LB_A2FF A2FF
gonc LB_A2FF
; .con 0x01B ; GONC +03 LB_A2FD A2FD
gonc LB_A2FD
; .con 0x083 ; GONC +10 LB_A30B A30B
gonc LB_A30B
; .con 0x26B ; GONC -33 LB_A2C9 A2C9
gonc LB_A2C9
LB_A2FD: .con 0x321 ; GOLNC OFF 11C8 ; HP41 SYSTEM ROM 1
.con 0x046 ;
LB_A2FF: .con 0x261 ; GSUBNC RSTKB 0098 ; HP41 SYSTEM ROM 0
.con 0x000 ;
.con 0x3D9 ; GSUBNC CLRLCD 2CF6 ; HP41 SYSTEM ROM 2
.con 0x0B0 ;
.con 0x130 ; LDI 02E
.con 0x02E ;
.con 0x3A8 ; REGN=C (14)d
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x0B0 ; C=N
.con 0x0EE ; BCEX ALL
.con 0x0B9 ; GOLNC RCL 122E ; HP41 SYSTEM ROM 1
LB_A30B: .con 0x04A ;
.con 0x198 ; C=M
.con 0x2EE ; ?C#0 ALL
; .con 0x037 ; GOC +06 LB_A314 A314
goc LB_A314
.con 0x265 ; GSUBNC BLINK 0899 ; HP41 SYSTEM ROM 0
.con 0x020 ;
;LB_A311: .con 0x369 ; GOL41C LB_A2C9 A2C9 ; GSUBNC 0FDA, address in same Quad
LB_A311: RGO LB_A2C9
; .con 0x03C ;
; .con 0x2C9 ;
LB_A314: .con 0x26E ; C=C-1 ALL
.con 0x158 ; M=C
.con 0x0B0 ; C=N
.con 0x3CE ; CSR ALL
.con 0x070 ; N=C
; .con 0x379 ; GSB41C LB_A339 A339 ; GSUBNC 0FDE, address in same Quad
RXQ LB_A339
; .con 0x03C ;
; .con 0x339 ;
.con 0x0A6 ; ACEX S&X
.con 0x3A8 ; REGN=C (14)d
.con 0x3A8 ; REGN=C (14)d
LB_A31F: .con 0x130 ; LDI 01F
.con 0x01F ;
.con 0x3E8 ; REGN=C (15)e
; .con 0x37B ; GONC -11 LB_A311 A311
gonc LB_A311
LB_A323: .con 0x106 ; A=C S&X
.con 0x198 ; C=M
.con 0x22E ; C=C+1 ALL
.con 0x158 ; M=C
.con 0x0B0 ; C=N
.con 0x39C ; PT= 0
.con 0x2FC ; RCR 13
.con 0x0A2 ; ACEX @R
.con 0x070 ; N=C
; .con 0x379 ; GSB41C LB_A339 A339 ; GSUBNC 0FDE, address in same Quad
RXQ LB_A339
; .con 0x03C ;
; .con 0x339 ;
.con 0x3A8 ; REGN=C (14)d
.con 0x0B0 ; C=N
.con 0x33C ; RCR 1
.con 0x130 ; LDI 001
.con 0x001 ;
.con 0x10E ; A=C ALL
; .con 0x379 ; GSB41C LB_A342 A342 ; GSUBNC 0FDE, address in same Quad
RXQ LB_A342
; .con 0x03C ;
; .con 0x342 ;
; .con 0x33B ; GONC -19 LB_A31F A31F
gonc LB_A31F
LB_A339: .con 0x130 ; LDI 020
.con 0x020 ;
.con 0x31C ; PT= 1
.con 0x106 ; A=C S&X
LB_A33D: .con 0x3B8 ; C=REGN (14)d
.con 0x36A ; ?A#C R<-
; .con 0x3F3 ; GONC -02 LB_A33D A33D
gonc LB_A33D
.con 0x3F8 ; C=REGN (15)e
.con 0x3E0 ; RTN
LB_A342: .con 0x1A6 ; A=A-1 S&X
.con 0x360 ; RTNC
.con 0x08E ; B=A ALL
.con 0x2DC ; PT= 13
.con 0x046 ; C=0 S&X
.con 0x250 ; LC 9
.con 0x0BE ; ACEX MS
.con 0x31E ; ?A<C MS
; .con 0x027 ; GOC +04 LB_A34E A34E
goc LB_A34E
.con 0x130 ; LDI 003
.con 0x003 ;
; .con 0x01B ; GONC +03 LB_A350 A350
gonc LB_A350
LB_A34E: .con 0x0BE ; ACEX MS
.con 0x25E ; C=A-C MS
LB_A350: .con 0x2FC ; RCR 13
.con 0x3E8 ; REGN=C (15)e
.con 0x0CE ; C=B ALL
.con 0x2FC ; RCR 13
.con 0x10E ; A=C ALL
.con 0x066 ; ABEX S&X
; .con 0x363 ; GONC -14 LB_A342 A342
gonc LB_A342
LB_A357: .con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x278 ; C=REGN ( 9)Q
.con 0x27E ; C=C-1 MS
.con 0x049 ; GOLC ABTSEQ 0D12 ; HP41 SYSTEM ROM 0
.con 0x037 ;
.con 0x11E ; A=C MS
.con 0x05E ; C=0 MS
.con 0x3CE ; CSR ALL
.con 0x0BE ; ACEX MS
.con 0x268 ; REGN=C ( 9)Q
; .con 0x1BB ; GONC +37 LB_A399 A399
gonc LB_A399
.con 0x08D ;
.con 0x013 ;
.con 0x016 ;
.con 0x03E ;
.con 0x018 ;
.con 0x005 ;
.NAME "HEX>VSM"
HEX>VSM: .con 0x04E ; C=0 ALL
.con 0x268 ; REGN=C ( 9)Q
.con 0x3C1 ; GSUBNC CLLCDE 2CF0 ; HP41 SYSTEM ROM 2
.con 0x0B0 ;
.con 0x3BD ; GSUBNC MESSL 07EF ; 008 220
.con 0x01C ;
.con 0x008 ;
.con 0x220 ;
LB_A372: .con 0x115 ; GSUBNC NEXT1 0E45 ; HP41 SYSTEM ROM 0
.con 0x038 ;
; .con 0x31B ; GONC -1D LB_A357 A357
gonc LB_A357
.con 0x04C ; ST=1? 4
; .con 0x14B ; GONC +29 LB_A39F A39F
gonc LB_A39F
.con 0x35E ; ?A#0 MS
; .con 0x3D3 ; GONC -06 LB_A372 A372
gonc LB_A372
.con 0x130 ; LDI 007
.con 0x007 ;
.con 0x33C ; RCR 1
.con 0x3E1 ; GOLC EAF8
.con 0x3AB ;
.con 0x0BE ; ACEX MS
.con 0x2FC ; RCR 13
.con 0x3E8 ; REGN=C (15)e
.con 0x106 ; A=C S&X
.con 0x130 ; LDI 009
.con 0x009 ;
.con 0x146 ; A=A+C S&X
LB_A385: .con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x130 ; LDI 004
.con 0x004 ;
.con 0x33C ; RCR 1
.con 0x11E ; A=C MS
.con 0x278 ; C=REGN ( 9)Q
.con 0x0BE ; ACEX MS
.con 0x31E ; ?A<C MS
; .con 0x05B ; GONC +0B LB_A399 A399
gonc LB_A399
.con 0x05E ; C=0 MS
.con 0x2FC ; RCR 13
.con 0x39C ; PT= 0
.con 0x0A2 ; ACEX @R
.con 0x0BE ; ACEX MS
.con 0x23E ; C=C+1 MS
.con 0x268 ; REGN=C ( 9)Q
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
; .con 0x2D3 ; GONC -26 LB_A372 A372
gonc LB_A372
LB_A399: .con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x130 ; LDI 020
.con 0x020 ;
.con 0x3A8 ; REGN=C (14)d
; .con 0x2A3 ; GONC -2C LB_A372 A372
gonc LB_A372
LB_A39F: .con 0x00C ; ST=1? 3
; .con 0x043 ; GONC +08 LB_A3A8 A3A8
gonc LB_A3A8
.con 0x130 ; LDI 003
.con 0x003 ;
.con 0x0BE ; ACEX MS
.con 0x2FC ; RCR 13
.con 0x3E8 ; REGN=C (15)e
.con 0x106 ; A=C S&X
; .con 0x2F3 ; GONC -22 LB_A385 A385
gonc LB_A385
LB_A3A8: .con 0x130 ; LDI 370
.con 0x370 ;
.con 0x106 ; A=C S&X
.con 0x0B0 ; C=N
.con 0x366 ; ?A#C S&X
; .con 0x22F ; GOC -3B LB_A372 A372
goc LB_A372
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x278 ; C=REGN ( 9)Q
.con 0x39C ; PT= 0
LB_A3B2: .con 0x102 ; A=C @R
.con 0x1EE ; C=C+C ALL
.con 0x3DC ; INCPT
.con 0x054 ; ?PT= 4
; .con 0x3E3 ; GONC -04 LB_A3B2 A3B2
gonc LB_A3B2
.con 0x2FC ; RCR 13
.con 0x3DC ; INCPT
.con 0x102 ; A=C @R
.con 0x042 ; C=0 @R
.con 0x1EE ; C=C+C ALL
.con 0x1EE ; C=C+C ALL
.con 0x33C ; RCR 1
.con 0x3D4 ; DECPT
.con 0x102 ; A=C @R
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x3BD ; GSUBNC MESSL 07EF ; 00F 003 014 220
.con 0x01C ;
.con 0x00F ;
.con 0x003 ;
.con 0x014 ;
.con 0x220 ;
.con 0x0AE ; ACEX ALL
.con 0x0BC ; RCR 5
.con 0x31C ; PT= 1
.con 0x0D0 ; LC 3
.con 0x106 ; A=C S&X
.con 0x130 ; LDI 00A
.con 0x00A ;
.con 0x302 ; ?A<C @R
; .con 0x027 ; GOC +04 LB_A3D4 A3D4
goc LB_A3D4
.con 0x262 ; C=C-1 @R
.con 0x242 ; C=A-C @R
; .con 0x013 ; GONC +02 LB_A3D5 A3D5
gonc LB_A3D5
LB_A3D4: .con 0x0A6 ; ACEX S&X
LB_A3D5: .con 0x3E8 ; REGN=C (15)e
.con 0x130 ; LDI 02D
.con 0x02D ;
.con 0x3E8 ; REGN=C (15)e
.con 0x2FC ; RCR 13
.con 0x3DC ; INCPT
.con 0x0D0 ; LC 3
.con 0x3E8 ; REGN=C (15)e
.con 0x130 ; LDI 02D
.con 0x02D ;
.con 0x3E8 ; REGN=C (15)e
.con 0x2FC ; RCR 13
.con 0x3D8 ; CSTEX
.con 0x304 ; ST=0 1
.con 0x204 ; ST=0 2
LB_A3E4: .con 0x004 ; ST=0 3
.con 0x048 ; ST=1 4
.con 0x088 ; ST=1 5
.con 0x144 ; ST=0 6
.con 0x284 ; ST=0 7
.con 0x3D8 ; CSTEX
.con 0x3E8 ; REGN=C (15)e
.con 0x2FC ; RCR 13
.con 0x056 ; C=0 XS
.con 0x3DC ; INCPT
.con 0x3D8 ; CSTEX
.con 0x054 ; ?PT= 4
; .con 0x3A3 ; GONC -0C LB_A3E4 A3E4
gonc LB_A3E4
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x215 ; GSUBNC RSTSQ 0385 ; HP41 SYSTEM ROM 0
.con 0x00C ;
.con 0x261 ; GSUBNC RSTKB 0098 ; HP41 SYSTEM ROM 0
.con 0x000 ;
.con 0x201 ; GOLNC 0380
.con 0x00E ;
LB_A3F9: .con 0x130 ; LDI 370
.con 0x370 ;
.con 0x106 ; A=C S&X
.con 0x0B0 ; C=N
.con 0x366 ; ?A#C S&X
; .con 0x18F ; GOC +31 LB_A42F A42F
goc LB_A42F
.con 0x3BD ; GSUBNC MESSL 07EF ; 001 004 004 012 005 013 013 220
.con 0x01C ;
.con 0x001 ;
.con 0x004 ;
.con 0x004 ;
.con 0x012 ;
.con 0x005 ;
.con 0x013 ;
.con 0x013 ;
.con 0x220 ;
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x215 ; GSUBNC RSTSQ 0385 ; HP41 SYSTEM ROM 0
.con 0x00C ;
.con 0x278 ; C=REGN ( 9)Q
.con 0x10E ; A=C ALL
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x04E ; C=0 ALL
.con 0x0BA ; ACEX M
.con 0x33C ; RCR 1
.con 0x20E ; C=A+C ALL
.con 0x03C ; RCR 3
.con 0x05C ; PT= 4
LB_A417: .con 0x106 ; A=C S&X
.con 0x130 ; LDI 030
.con 0x030 ;
.con 0x146 ; A=A+C S&X
.con 0x130 ; LDI 03A
.con 0x03A ;
.con 0x306 ; ?A<C S&X
; .con 0x01F ; GOC +03 LB_A421 A421
goc LB_A421
.con 0x266 ; C=C-1 S&X
.con 0x1C6 ; A=A-C S&X
LB_A421: .con 0x0A6 ; ACEX S&X
.con 0x3E8 ; REGN=C (15)e
.con 0x046 ; C=0 S&X
.con 0x2FC ; RCR 13
.con 0x3D4 ; DECPT
.con 0x394 ; ?PT= 0
; .con 0x383 ; GONC -10 LB_A417 A417
gonc LB_A417
.con 0x261 ; GSUBNC RSTKB 0098 ; HP41 SYSTEM ROM 0
.con 0x000 ;
.con 0x046 ; C=0 S&X
.AD=C
.con 0x1FD ; GOLNC 037F
.con 0x00E ;
;LB_A42E: .con 0x25B ; GONC -35 LB_A3F9 A3F9
LB_A42E: gonc LB_A3F9
;LB_A42F: .con 0x183 ; GONC +30 LB_A45F A45F
LB_A42F: gonc LB_A45F
LB_A430: .con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x278 ; C=REGN ( 9)Q
.con 0x0AE ; ACEX ALL
.con 0x1BE ; A=A-1 MS
.con 0x049 ; GOLC ABTSEQ 0D12 ; HP41 SYSTEM ROM 0
.con 0x037 ;
.con 0x35E ; ?A#0 MS
; .con 0x0FB ; GONC +1F VSM>HEX A457
gonc VSM>HEX
.con 0x05E ; C=0 MS
.con 0x23E ; C=C+1 MS
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x37E ; ?A#C MS
; .con 0x037 ; GOC +06 LB_A444 A444
goc LB_A444
.con 0x01C ; PT= 3
.con 0x002 ; A=0 @R
.con 0x130 ; LDI 020
.con 0x020 ;
.con 0x3A8 ; REGN=C (14)d
LB_A444: .con 0x130 ; LDI 020
.con 0x020 ;
.con 0x3A8 ; REGN=C (14)d
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x0AE ; ACEX ALL
.con 0x1E6 ; C=C+C S&X
.con 0x3C6 ; CSR S&X
.con 0x268 ; REGN=C ( 9)Q
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
; .con 0x083 ; GONC +10 LB_A45F A45F
gonc LB_A45F
.con 0x098 ;
.con 0x005 ;
.con 0x008 ;
.con 0x03E ;
.con 0x00D ;
.con 0x013 ;
.NAME "VSM>HEX"
VSM>HEX: .con 0x04E ; C=0 ALL
.con 0x268 ; REGN=C ( 9)Q
.con 0x3C1 ; GSUBNC CLLCDE 2CF0 ; HP41 SYSTEM ROM 2
.con 0x0B0 ;
.con 0x3BD ; GSUBNC MESSL 07EF ; 00F 220
.con 0x01C ;
.con 0x00F ;
.con 0x220 ;
LB_A45F: .con 0x115 ; GSUBNC NEXT1 0E45 ; HP41 SYSTEM ROM 0
.con 0x038 ;
; .con 0x27B ; GONC -31 LB_A430 A430
gonc LB_A430
.con 0x00C ; ST=1? 3
; .con 0x25B ; GONC -35 LB_A42E A42E
gonc LB_A42E
.con 0x130 ; LDI 038
.con 0x038 ;
.con 0x33C ; RCR 1
.con 0x31E ; ?A<C MS
; .con 0x3BB ; GONC -09 LB_A45F A45F
gonc LB_A45F
.con 0x0BE ; ACEX MS
.con 0x11E ; A=C MS
.con 0x2FC ; RCR 13
.con 0x3E8 ; REGN=C (15)e
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x278 ; C=REGN ( 9)Q
.con 0x2FE ; ?C#0 MS
; .con 0x067 ; GOC +0C LB_A47D A47D
goc LB_A47D
.con 0x23E ; C=C+1 MS
.con 0x0BE ; ACEX MS
.con 0x27C ; RCR 9
.con 0x0BE ; ACEX MS
LB_A476: .con 0x268 ; REGN=C ( 9)Q
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x130 ; LDI 02D
.con 0x02D ;
.con 0x3E8 ; REGN=C (15)e
; .con 0x31B ; GONC -1D LB_A45F A45F
gonc LB_A45F
LB_A47D: .con 0x27E ; C=C-1 MS
.con 0x2FE ; ?C#0 MS
; .con 0x0A7 ; GOC +14 LB_A493 A493
goc LB_A493
.con 0x2DC ; PT= 13
.con 0x110 ; LC 4
.con 0x31E ; ?A<C MS
; .con 0x03F ; GOC +07 LB_A48A A48A
goc LB_A48A
LB_A484: .con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
.con 0x130 ; LDI 020
.con 0x020 ;
.con 0x3A8 ; REGN=C (14)d
;LB_A489: .con 0x2B3 ; GONC -2A LB_A45F A45F
LB_A489: gonc LB_A45F
LB_A48A: .con 0x05E ; C=0 MS
.con 0x07C ; RCR 4
.con 0x0BE ; ACEX MS
.con 0x1FE ; C=C+C MS
.con 0x1FE ; C=C+C MS
.con 0x0FC ; RCR 10
.con 0x23E ; C=C+1 MS
.con 0x23E ; C=C+1 MS
; .con 0x323 ; GONC -1C LB_A476 A476
gonc LB_A476
LB_A493: .con 0x09E ; B=A MS
.con 0x23E ; C=C+1 MS
.con 0x23E ; C=C+1 MS
.con 0x11E ; A=C MS
.con 0x2DC ; PT= 13
.con 0x1D0 ; LC 7
.con 0x31E ; ?A<C MS
; .con 0x353 ; GONC -16 LB_A484 A484
gonc LB_A484
.con 0x3DC ; INCPT
.con 0x0D0 ; LC 3
.con 0x37E ; ?A#C MS
; .con 0x077 ; GOC +0E LB_A4AC A4AC
goc LB_A4AC
.con 0x07E ; ABEX MS
.con 0x27E ; C=C-1 MS
.con 0x31E ; ?A<C MS
; .con 0x313 ; GONC -1E LB_A484 A484
gonc LB_A484
.con 0x05E ; C=0 MS
.con 0x33C ; RCR 1
.con 0x0BE ; ACEX MS
.con 0x2FC ; RCR 13
.con 0x0DE ; C=B MS
LB_A4A8: .con 0x268 ; REGN=C ( 9)Q
.con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
; .con 0x2F3 ; GONC -22 LB_A489 A489
gonc LB_A489
LB_A4AC: .con 0x278 ; C=REGN ( 9)Q
.con 0x1E6 ; C=C+C S&X
.con 0x1E6 ; C=C+C S&X
.con 0x1E6 ; C=C+C S&X
.con 0x0AE ; ACEX ALL
.con 0x046 ; C=0 S&X
.con 0x0DE ; C=B MS
.con 0x2FC ; RCR 13
.con 0x146 ; A=A+C S&X
.con 0x0AE ; ACEX ALL
.con 0x23E ; C=C+1 MS
; .con 0x38B ; GONC -0F LB_A4A8 A4A8
gonc LB_A4A8
.con 0x092 ;
.con 0x004 ;
.con 0x001 ;
.con 0x010 ;
.con 0x00F ;
.NAME "A<>R"
A<>R: .con 0x1A0 ; CLRABC
.con 0x130 ; LDI 005
.con 0x005 ;
.con 0x05C ; PT= 4
; .con 0x043 ; GONC +08 LB_A54F A54F
gonc LB_A54F
.con 0x092 ;
.con 0x03E ;
.con 0x03C ;
.con 0x014 ;
.NAME "ST<>R"
ST<>R: .con 0x1A0 ; CLRABC
.con 0x09C ; PT= 5
LB_A54F: .con 0x158 ; M=C
.con 0x3B8 ; C=REGN (14)d
.con 0x05A ; C=0 M
.con 0x046 ; C=0 S&X
.con 0x1BC ; RCR 11
.con 0x1EE ; C=C+C ALL
.con 0x11A ; A=C M
.con 0x05A ; C=0 M
.con 0x1EE ; C=C+C ALL
.con 0x1FA ; C=C+C M
.con 0x15A ; A=A+C M
.con 0x05A ; C=0 M
.con 0x1EE ; C=C+C ALL
.con 0x1FA ; C=C+C M
.con 0x1FA ; C=C+C M
.con 0x15A ; A=A+C M
.con 0x05A ; C=0 M
.con 0x2FC ; RCR 13
.con 0x15A ; A=A+C M
.con 0x04E ; C=0 ALL
.con 0x0BA ; ACEX M
.con 0x03C ; RCR 3
.con 0x0A6 ; ACEX S&X
.con 0x378 ; C=REGN (13)c
.con 0x03C ; RCR 3
.con 0x146 ; A=A+C S&X
LB_A569: .con 0x086 ; B=A S&X
.con 0x198 ; C=M
.con 0x270 ; DADD=C
.con 0x038 ; C=REGN ( 0)T
.con 0x0F0 ; CNEX
.con 0x0C6 ; C=B S&X
.con 0x270 ; DADD=C
.con 0x038 ; C=REGN ( 0)T
.con 0x0F0 ; CNEX
.con 0x2F0 ; DATA=C
.con 0x198 ; C=M
.con 0x270 ; DADD=C
.con 0x0F0 ; CNEX
.con 0x2F0 ; DATA=C
.con 0x3D4 ; DECPT
.con 0x394 ; ?PT= 0
.con 0x360 ; RTNC
.con 0x166 ; A=A+1 S&X
.con 0x1D8 ; CMEX
.con 0x226 ; C=C+1 S&X
.con 0x1D8 ; CMEX
; .con 0x35B ; GONC -15 LB_A569 A569
gonc LB_A569
.NAME "GROM"
GROM: .con 0x0F8 ; C=REGN ( 3)X
.con 0x1BC ; RCR 11
.con 0x1E0 ; GOTOC
.con 0x3E0 ; RTN
.con 0x0B2 ;
.con 0x034 ;
.con 0x034 ;
.NAME "NNN>HEX"
NNN>HEX: .con 0x0F8 ; C=REGN ( 3)X
.con 0x0EE ; BCEX ALL
.con 0x2A0 ; SETDEC
LB_A876: .con 0x04E ; C=0 ALL
.con 0x228 ; REGN=C ( 8)P
.con 0x1E8 ; REGN=C ( 7)O
.con 0x01C ; PT= 3
.con 0x190 ; LC 6
.con 0x31C ; PT= 1
.con 0x0D0 ; LC 3
.con 0x10E ; A=C ALL
.con 0x04E ; C=0 ALL
LB_A87F: .con 0x37C ; RCR 12
.con 0x0EE ; BCEX ALL
.con 0x2FC ; RCR 13
.con 0x0EE ; BCEX ALL
.con 0x2C2 ; ?B#0 @R
; .con 0x013 ; GONC +02 LB_A886 A886
gonc LB_A886
.con 0x308 ; ST=1 1
LB_A886: .con 0x30C ; ST=1? 1
; .con 0x033 ; GONC +06 LB_A88D A88D
gonc LB_A88D
.con 0x062 ; ABEX @R
.con 0x206 ; C=A+C S&X
.con 0x362 ; ?A#C @R
; .con 0x013 ; GONC +02 LB_A88D A88D
gonc LB_A88D
.con 0x222 ; C=C+1 @R
LB_A88D: .con 0x1BA ; A=A-1 M
; .con 0x38B ; GONC -0F LB_A87F A87F
gonc LB_A87F
.con 0x20C ; ST=1? 2
; .con 0x027 ; GOC +04 LB_A894 A894
goc LB_A894
.con 0x208 ; ST=1 2
.con 0x1A8 ; REGN=C ( 6)N
; .con 0x31B ; GONC -1D LB_A876 A876
gonc LB_A876
LB_A894: .con 0x30C ; ST=1? 1
; .con 0x017 ; GOC +02 LB_A897 A897
goc LB_A897
.con 0x0A6 ; ACEX S&X
LB_A897: .con 0x168 ; REGN=C ( 5)M
.con 0x2CC ; ST=1? 13
.con 0x360 ; RTNC
.con 0x260 ; SETHEX
.con 0x191 ; GOLNC XAVIEW 0364 ; HP41 SYSTEM ROM 0
.NAME "HXENTRY"
HXENTRY: .con 0x345 ; GSUBNC CLA 10D1 ; HP41 SYSTEM ROM 1
.con 0x040 ;
.con 0x3C1 ; GSUBNC CLLCDE 2CF0 ; HP41 SYSTEM ROM 2
.con 0x0B0 ;
LB_A8A8: .con 0x115 ; GSUBNC NEXT1 0E45 ; HP41 SYSTEM ROM 0
.con 0x038 ;
; .con 0x07B ; GONC +0F LB_A8B9 A8B9
gonc LB_A8B9
.con 0x04C ; ST=1? 4
; .con 0x11B ; GONC +23 LB_A8CF A8CF
gonc LB_A8CF
.con 0x35E ; ?A#0 MS
; .con 0x3D3 ; GONC -06 LB_A8A8 A8A8
gonc LB_A8A8
.con 0x130 ; LDI 007
.con 0x007 ;
.con 0x33C ; RCR 1
.con 0x31E ; ?A<C MS
; .con 0x3AB ; GONC -0B LB_A8A8 A8A8
gonc LB_A8A8
.con 0x0BE ; ACEX MS
.con 0x2FC ; RCR 13
.con 0x3E8 ; REGN=C (15)e
.con 0x110 ; LC 4
; .con 0x0EB ; GONC +1D LB_A8D5 A8D5
gonc LB_A8D5
LB_A8B9: .con 0x3B8 ; C=REGN (14)d
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x238 ; C=REGN ( 8)P
.con 0x10E ; A=C ALL
.con 0x1F8 ; C=REGN ( 7)O
.con 0x0AA ; ACEX R<-
.con 0x23C ; RCR 2
.con 0x2F0 ; DATA=C
.con 0x1B8 ; C=REGN ( 6)N
.con 0x0AA ; ACEX R<-
.con 0x23C ; RCR 2
.con 0x2F0 ; DATA=C
.con 0x178 ; C=REGN ( 5)M
.con 0x04A ; C=0 R<-
.con 0x0AA ; ACEX R<-
.con 0x23C ; RCR 2
.con 0x2F0 ; DATA=C
.con 0x0AE ; ACEX ALL
.con 0x23C ; RCR 2
.con 0x228 ; REGN=C ( 8)P
; .con 0x073 ; GONC +0E LB_A8DC A8DC
gonc LB_A8DC
LB_A8CF: .con 0x00C ; ST=1? 3
; .con 0x07B ; GONC +0F LB_A8DF A8DF
gonc LB_A8DF
.con 0x0BE ; ACEX MS
.con 0x2FC ; RCR 13
.con 0x0D0 ; LC 3
.con 0x368 ; REGN=C (13)c
LB_A8D5: .con 0x058 ; G=C
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x051 ; GSUBNC APNDNW 2D14 ; HP41 SYSTEM ROM 2
.con 0x0B4 ;
.con 0x042 ; C=0 @R
.con 0x058 ; G=C
LB_A8DC: .con 0x3D9 ; GSUBNC ENLCD 07F6 ; HP41 SYSTEM ROM 0
.con 0x01C ;
; .con 0x253 ; GONC -36 LB_A8A8 A8A8
gonc LB_A8A8
LB_A8DF: .con 0x28C ; ST=1? 7
; .con 0x01B ; GONC +03 LB_A8E3 A8E3
gonc LB_A8E3
.con 0x2C4 ; ST=0 13
; .con 0x03B ; GONC +07 LB_A8E9 A8E9
gonc LB_A8E9
LB_A8E3: .con 0x130 ; LDI 370
.con 0x370 ;
.con 0x106 ; A=C S&X
.con 0x0B0 ; C=N
.con 0x366 ; ?A#C S&X
; .con 0x207 ; GOC -40 LB_A8A8 A8A8
goc LB_A8A8
LB_A8E9: .con 0x3D9 ; GSUBNC CLRLCD 2CF6 ; HP41 SYSTEM ROM 2
.con 0x0B0 ;
.con 0x261 ; GSUBNC RSTKB 0098 ; HP41 SYSTEM ROM 0
.con 0x000 ;
.con 0x149 ; GSUBNC ENCP00 0952 ; HP41 SYSTEM ROM 0
.con 0x024 ;
.con 0x215 ; GSUBNC RSTSQ 0385 ; HP41 SYSTEM ROM 0
.con 0x00C ;
LB_A8F1: .con 0x130 ; LDI 049
.con 0x049 ;
.con 0x23C ; RCR 2
.con 0x0EE ; BCEX ALL
.con 0x35C ; PT= 12
.con 0x00E ; A=0 ALL
.con 0x1B8 ; C=REGN ( 6)N
LB_A8F8: .con 0x0AE ; ACEX ALL
LB_A8F9: .con 0x33E ; ?A<B MS
; .con 0x017 ; GOC +02 LB_A8FC A8FC
goc LB_A8FC
.con 0x122 ; A=A+B @R
LB_A8FC: .con 0x3EE ; ASL ALL
.con 0x0BE ; ACEX MS
.con 0x3EE ; ASL ALL
.con 0x2FC ; RCR 13
.con 0x34E ; ?A#0 ALL
; .con 0x3C7 ; GOC -08 LB_A8F9 A8F9
goc LB_A8F9
.con 0x30C ; ST=1? 1
; .con 0x02F ; GOC +05 LB_A908 A908
goc LB_A908
.con 0x308 ; ST=1 1
.con 0x10E ; A=C ALL
.con 0x178 ; C=REGN ( 5)M
; .con 0x38B ; GONC -0F LB_A8F8 A8F8
gonc LB_A8F8
LB_A908: .con 0x0EE ; BCEX ALL
.con 0x0B9 ; GOLNC RCL 122E ; HP41 SYSTEM ROM 1
.con 0x04A ;
.con 0x08E ;
.con 0x00E ;
.con 0x00E ;
.con 0x03E ;
.con 0x018 ;
.con 0x005 ;
.NAME "HEX>NNN"
;HEX>NNN: .con 0x369 ; GOL41C LB_A8F1 A8F1 ; GSUBNC 0FDA, address in same Quad
HEX>NNN: RGO LB_A8F1
; .con 0x03C ;
; .con 0x0F1 ;
.NAME "BIN>BCD"
BIN>BCD: .con 0x0F8 ; C=REGN ( 3)X
LB_AEA3: .con 0x106 ; A=C S&X
.con 0x130 ; LDI 010
.con 0x010 ;
.con 0x270 ; DADD=C
.con 0x2DC ; PT= 13
.con 0x110 ; LC 4
.con 0x11E ; A=C MS
.con 0x3A1 ; GSUBNC GENNUM 05E8 ; HP41 SYSTEM ROM 0
.con 0x014 ;
.con 0x0AE ; ACEX ALL
.con 0x11C ; PT= 8
.con 0x04A ; C=0 R<-
.con 0x270 ; DADD=C
.con 0x39C ; PT= 0
.con 0x0D0 ; LC 3
.con 0x010 ; LC 0
.con 0x0AE ; ACEX ALL
LB_AEB4: .con 0x342 ; ?A#0 @R
; .con 0x027 ; GOC +04 LB_AEB9 AEB9
goc LB_AEB9
.con 0x3FA ; ASL M
.con 0x1A6 ; A=A-1 S&X
; .con 0x3E3 ; GONC -04 LB_AEB4 AEB4
gonc LB_AEB4
LB_AEB9: .con 0x0AE ; ACEX ALL
.con 0x2FA ; ?C#0 M
; .con 0x017 ; GOC +02 LB_AEBD AEBD
goc LB_AEBD
.con 0x04E ; C=0 ALL
LB_AEBD: .con 0x0E8 ; REGN=C ( 3)X
.con 0x3E0 ; RTN
.NAME "BCD>BIN"
;BCD>BIN: .con 0x379 ; GSB41C LB_AED3 AED3 ; GSUBNC 0FDE, address in same Quad
BCD>BIN: RXQ LB_AED3
; .con 0x03C ;
; .con 0x2D3 ;
.con 0x0E8 ; REGN=C ( 3)X
.con 0x3E0 ; RTN
LB_AED3: .con 0x0F8 ; C=REGN ( 3)X
.con 0x10E ; A=C ALL
.con 0x1BE ; A=A-1 MS
.con 0x1BE ; A=A-1 MS
.con 0x389 ; GOLC ERRAD 14E2 ; HP41 SYSTEM ROM 1
.con 0x053 ;
.con 0x130 ; LDI 004
.con 0x004 ;
.con 0x306 ; ?A<C S&X
.con 0x289 ; GOLNC ERROF 00A2 ; HP41 SYSTEM ROM 0
.con 0x002 ;
.con 0x266 ; C=C-1 S&X
.con 0x0AE ; ACEX ALL
.con 0x366 ; ?A#C S&X
; .con 0x023 ; GONC +04 LB_AEE5 AEE5
gonc LB_AEE5
.con 0x38D ; GSUBNC BCDBIN 02E3 ; HP41 SYSTEM ROM 0
.con 0x008 ;
; .con 0x07B ; GONC +0F LB_AEF3 AEF3
gonc LB_AEF3
LB_AEE5: .con 0x27C ; RCR 9
.con 0x11A ; A=C M
.con 0x05A ; C=0 M
.con 0x3E1 ; GSUBNC GOTINT 02F8 ; HP41 SYSTEM ROM 0
.con 0x008 ;
.con 0x106 ; A=C S&X
.con 0x01C ; PT= 3
.con 0x130 ; LDI 3E8
.con 0x3E8 ;
.con 0x1A2 ; A=A-1 @R
LB_AEEF: .con 0x146 ; A=A+C S&X
.con 0x1A2 ; A=A-1 @R
; .con 0x3F3 ; GONC -02 LB_AEEF AEEF
gonc LB_AEEF
.con 0x0A6 ; ACEX S&X
LB_AEF3: .con 0x05E ; C=0 MS
.con 0x05A ; C=0 M
.con 0x3E0 ; RTN
.NAME "WROM"
WROM: .con 0x0B8 ; C=REGN ( 2)Y
.con 0x0E6 ; BCEX S&X
.con 0x0F8 ; C=REGN ( 3)X
.con 0x1BC ; RCR 11
.con 0x0C6 ; C=B S&X
.con 0x040 ; WMLDL
.con 0x3E0 ; RTN
.NAME "RROM"
RROM: .con 0x0F8 ; C=REGN ( 3)X
.con 0x1BC ; RCR 11
.con 0x330 ; CXISA
.con 0x05A ; C=0 M
.con 0x05E ; C=0 MS
.con 0x0A8 ; REGN=C ( 2)Y
.con 0x0F8 ; C=REGN ( 3)X
.con 0x22E ; C=C+1 ALL
.con 0x0E8 ; REGN=C ( 3)X
.con 0x3E0 ; RTN
.NAME "SROM"
SROM: .con 0x0F8 ; C=REGN ( 3)X
.con 0x130 ; LDI 000
.con 0x000 ;
.con 0x23A ; C=C+1 M
.con 0x1BC ; RCR 11
.con 0x11A ; A=C M
.con 0x0B8 ; C=REGN ( 2)Y
.con 0x106 ; A=C S&X
.con 0x0F8 ; C=REGN ( 3)X
.con 0x1BC ; RCR 11
LB_AF4A: .con 0x23A ; C=C+1 M
.con 0x37A ; ?A#C M
; .con 0x023 ; GONC +04 LB_AF50 AF50
gonc LB_AF50
.con 0x330 ; CXISA
.con 0x366 ; ?A#C S&X
; .con 0x3DF ; GOC -05 LB_AF4A AF4A
goc LB_AF4A
LB_AF50: .con 0x046 ; C=0 S&X
.con 0x03C ; RCR 3
.con 0x0E8 ; REGN=C ( 3)X
.con 0x3E0 ; RTN
|
oeis/322/A322747.asm | neoneye/loda-programs | 11 | 168070 | <reponame>neoneye/loda-programs
; A322747: a(n) = sqrt(1 + A322746(2*n)).
; Submitted by <NAME>
; 1,5,161,8749,665857,65160501,7793761249,1101696200669,179689877047297,33215554576822501,6862186181491284001,1566923219786361397005,391868347839681254572801,106523078497331434142611733,31273034455313887578671676257,9861199411981740201459108013501,3323934356065162114649793157939201,1192687756756273462111153420161471429,453894216174714424946587255364852714401,182606294839821440285242771771899584149997,77435357832397812637911499906360751806752001,34520872166815532592141866692936237939669399285
mov $3,$0
mul $3,8
mov $4,1
lpb $0
sub $0,1
add $1,1
add $2,$3
mul $2,$1
add $4,$2
add $1,$4
mov $2,0
lpe
mov $0,$4
div $0,2
add $0,1
|
all.agda | hazelgrove/agda-popl17 | 14 | 7327 | -- this is effectively a CM make file. it just includes all the files that
-- exist in the directory in the right order so that one can check that
-- everything compiles cleanly and has no unfilled holes
-- data structures
open import List
open import Nat
open import Prelude
-- basic stuff: core definitions, etc
open import core
open import checks
open import judgemental-erase
open import judgemental-inconsistency
open import moveerase
open import examples
open import structural
-- first wave theorems
open import sensibility
open import aasubsume-min
open import determinism
-- second wave theorems (checksums)
open import reachability
open import constructability
|
tools/tz/gen_tz.adb | svn2github/matreshka | 24 | 12351 | <gh_stars>10-100
------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Localization, Internationalization, Globalization for Ada --
-- --
-- Tools Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2013, <NAME> <<EMAIL>> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE nor the names of its --
-- contributors may be used to endorse or promote products derived from --
-- this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR --
-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF --
-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING --
-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS --
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- This program generates timezone information from TZDATA.
------------------------------------------------------------------------------
with Ada.Characters.Wide_Wide_Latin_1;
with Ada.Containers.Vectors;
with Ada.Strings.Wide_Wide_Fixed;
with Ada.Unchecked_Deallocation;
with Ada.Wide_Wide_Text_IO;
with League.Application;
with League.Strings;
with Matreshka.Internals.Calendars.Gregorian;
with Matreshka.Internals.Calendars.Times;
procedure Gen_TZ is
use Matreshka.Internals.Calendars;
use Matreshka.Internals.Calendars.Gregorian;
use Matreshka.Internals.Calendars.Times;
type Time_Kinds is (Wall, Standard, UTC);
type Day_Kinds is (Number, Last_Sunday, Last_Saturday);
type TZ_Zone_Record is record
GMT_Offset : Relative_Time;
Rules : League.Strings.Universal_String;
Year : Year_Number;
Month : Month_Number := 1;
Day_Kind : Day_Kinds := Number;
Day : Day_Number := 1;
Hour : Hour_Number := 0;
Minute : Minute_Number := 0;
Second : Second_Number := 0;
Time_Kind : Time_Kinds := Wall;
end record;
type Time_Zone_Access is access all Internal_Time_Zone;
package TZ_Zone_Vectors is
new Ada.Containers.Vectors (Positive, TZ_Zone_Record);
type TZ_Zone_Info is record
Name : League.Strings.Universal_String;
Records : TZ_Zone_Vectors.Vector;
end record;
X_Open_Epoch : constant := 2_299_161;
Ticks_In_Day : constant := 24 * 60 * 60 * 10_000_000;
Ticks_In_Hour : constant := 60 * 60 * 10_000_000;
Ticks_In_Minute : constant := 60 * 10_000_000;
Ticks_In_Second : constant := 10_000_000;
procedure Load_TZ_File (File_Name : League.Strings.Universal_String);
function To_Absolute_Time
(Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Hour : Hour_Number;
Minute : Minute_Number;
Second : Second_Number) return Absolute_Time;
function To_Relative_Time
(Hour : Hour_Number;
Minute : Minute_Number;
Second : Second_Number) return Relative_Time;
function Image (Item : Absolute_Time) return Wide_Wide_String;
function Image (Item : Relative_Time) return Wide_Wide_String;
TZ : TZ_Zone_Info;
procedure Prepend
(Item : in out Time_Zone_Access;
Value : Zone_Record);
-----------
-- Image --
-----------
function Image (Item : Absolute_Time) return Wide_Wide_String is
Digit : constant
array (Absolute_Time range 0 .. 9) of Wide_Wide_Character
:= "0123456789";
Image : Wide_Wide_String := "000_000_000_000_0000000";
First : Natural := Image'Last + 1;
Aux : Absolute_Time := Item;
begin
while Aux /= 0 loop
First := First - 1;
if Image (First) = '_' then
First := First - 1;
end if;
Image (First) := Digit (Aux mod 10);
Aux := Aux / 10;
end loop;
return Image;
end Image;
-----------
-- Image --
-----------
function Image (Item : Relative_Time) return Wide_Wide_String is
Digit : constant
array (Relative_Time range 0 .. 9) of Wide_Wide_Character
:= "0123456789";
Image : Wide_Wide_String := "000_000_000_000_0000000";
First : Natural := Image'Last + 1;
Aux : Relative_Time := Item;
begin
while Aux /= 0 loop
First := First - 1;
if Image (First) = '_' then
First := First - 1;
end if;
Image (First) := Digit (Aux mod 10);
Aux := Aux / 10;
end loop;
return Image;
end Image;
------------------
-- Load_TZ_File --
------------------
procedure Load_TZ_File (File_Name : League.Strings.Universal_String) is
File : Ada.Wide_Wide_Text_IO.File_Type;
Buffer : Wide_Wide_String (1 .. 1024);
First : Positive;
Last : Natural;
Field_First : Positive;
Field_Last : Natural;
procedure Parse_Field;
-- Parses field. Sets Field_First and Field_Last to the first and last
-- characters of the field, excluding heading and traling spaces. Update
-- First to track current position.
procedure Parse_GMTOFF (Value : out Relative_Time);
-- Parses GMTOFF field of Zone record.
procedure Parse_Month (Value : out Month_Number);
-- Parses month name.
procedure Parse_Time
(Hour : out Hour_Number;
Minute : out Minute_Number;
Second : out Second_Number;
Kind : out Time_Kinds);
-- Parses time component with modifiers ('s').
procedure Parse_Zone_Common (Value : in out TZ_Zone_Record);
-- Parses common fields of Zone record.
-----------------
-- Parse_Field --
-----------------
procedure Parse_Field is
begin
-- Skip leading whitespaces.
for J in First .. Last loop
First := J;
exit when Buffer (J) /= ' '
and Buffer (J) /= Ada.Characters.Wide_Wide_Latin_1.HT;
end loop;
Field_First := First;
if Buffer (Field_First) = '"' then
-- Use of quatation mark is not supported.
raise Program_Error;
end if;
for J in First .. Last loop
if Buffer (J) = ' '
or Buffer (J) = Ada.Characters.Wide_Wide_Latin_1.HT
then
Field_Last := J - 1;
First := J + 1;
exit;
elsif J = Last then
Field_Last := Last;
First := Last + 1;
end if;
end loop;
Ada.Wide_Wide_Text_IO.Put_Line
(''' & Buffer (Field_First .. Field_Last) & ''');
end Parse_Field;
------------------
-- Parse_GMTOFF --
------------------
procedure Parse_GMTOFF (Value : out Relative_Time) is
Hour : Hour_Number := 0;
Minute : Minute_Number := 0;
Second : Second_Number := 0;
First : Positive := Field_First;
Last : Natural := Field_Last;
Minus : Boolean := False;
begin
-- Look for minus sign.
if Buffer (First) = '-' then
Minus := True;
First := First + 1;
end if;
-- Lookup for hour separator.
for J in First .. Field_Last loop
if Buffer (J) = ':' then
Last := J - 1;
exit;
end if;
end loop;
if First <= Last then
Hour := Hour_Number'Wide_Wide_Value (Buffer (First .. Last));
First := Last + 2;
Last := Field_Last;
end if;
-- Lookup for minute separator.
for J in First .. Field_Last loop
if Buffer (J) = ':' then
Last := J - 1;
exit;
end if;
end loop;
if First <= Last then
Minute := Minute_Number'Wide_Wide_Value (Buffer (First .. Last));
First := Last + 2;
Last := Field_Last;
end if;
-- Process second if any.
if First <= Last then
Second := Second_Number'Wide_Wide_Value (Buffer (First .. Last));
end if;
Value := To_Relative_Time (Hour, Minute, Second);
if Minus then
Value := -Value;
end if;
end Parse_GMTOFF;
-----------------
-- Parse_Month --
-----------------
procedure Parse_Month (Value : out Month_Number) is
Image : constant Wide_Wide_String
:= Buffer (Field_First .. Field_Last);
begin
if Image = "Jan" then
Value := 1;
elsif Image = "Feb" then
Value := 2;
elsif Image = "Mar" then
Value := 3;
elsif Image = "Apr" then
Value := 4;
elsif Image = "May" then
Value := 5;
elsif Image = "Jun" then
Value := 6;
elsif Image = "Jul" then
Value := 7;
elsif Image = "Aug" then
Value := 8;
elsif Image = "Sep" then
Value := 9;
elsif Image = "Oct" then
Value := 10;
elsif Image = "Nov" then
Value := 11;
elsif Image = "Dec" then
Value := 12;
else
raise Constraint_Error;
end if;
end Parse_Month;
----------------
-- Parse_Time --
----------------
procedure Parse_Time
(Hour : out Hour_Number;
Minute : out Minute_Number;
Second : out Second_Number;
Kind : out Time_Kinds)
is
First : Positive := Field_First;
Last : Natural := Field_Last;
begin
-- Set default values.
Hour := 0;
Minute := 0;
Second := 0;
Kind := Wall;
-- Lookup for hour separator.
for J in First .. Last loop
if Buffer (J) not in '0' .. '9' then
Last := J - 1;
exit;
end if;
end loop;
if First <= Last then
Hour := Hour_Number'Wide_Wide_Value (Buffer (First .. Last));
if Last = Field_Last then
First := Field_Last + 1;
elsif Buffer (Last + 1) = ':' then
First := Last + 2;
else
First := Last + 1;
end if;
end if;
-- Lookup for minute separator.
Last := Field_Last;
for J in First .. Field_Last loop
if Buffer (J) not in '0' .. '9' then
Last := J - 1;
exit;
end if;
end loop;
if First <= Last then
Minute := Minute_Number'Wide_Wide_Value (Buffer (First .. Last));
if Last = Field_Last then
First := Field_Last + 1;
elsif Buffer (Last + 1) = ':' then
First := Last + 2;
else
First := Last + 1;
end if;
end if;
-- Lookup for second separator.
Last := Field_Last;
for J in First .. Field_Last loop
if Buffer (J) not in '0' .. '9' then
Last := J - 1;
exit;
end if;
end loop;
if First <= Last then
Second := Second_Number'Wide_Wide_Value (Buffer (First .. Last));
if Last = Field_Last then
First := Field_Last + 1;
elsif Buffer (Last + 1) = ':' then
First := Last + 2;
else
First := Last + 1;
end if;
end if;
Last := Field_Last;
-- Parse modifier if any.
if First <= Last then
if Buffer (First .. Last) = "s" then
Kind := Standard;
elsif Buffer (First .. Last) = "u" then
Kind := UTC;
else
raise Constraint_Error;
end if;
end if;
end Parse_Time;
------------------------
-- Parse_Zone_Commmon --
------------------------
procedure Parse_Zone_Common (Value : in out TZ_Zone_Record) is
begin
-- Parse GMTOFF field.
Parse_Field;
Parse_GMTOFF (Value.GMT_Offset);
-- Process RULES field.
Parse_Field;
if Buffer (Field_First .. Field_Last) /= "-" then
Value.Rules :=
League.Strings.To_Universal_String
(Buffer (Field_First .. Field_Last));
end if;
-- Skip FORMAT field.
Parse_Field;
-- Process components of [UNTIL] field.
-- Year component.
Parse_Field;
if Field_First <= Field_Last then
Value.Year :=
Year_Number'Wide_Wide_Value
(Buffer (Field_First .. Field_Last));
else
Ada.Wide_Wide_Text_IO.Put_Line (">>> END OF TIME <<<");
Value.Year := Year_Number'Last;
end if;
-- Month component.
Parse_Field;
if Field_First <= Field_Last then
Parse_Month (Value.Month);
end if;
-- Day component.
Parse_Field;
if Field_First <= Field_Last then
-- Special values.
if Buffer (Field_First .. Field_Last) = "lastSun" then
Value.Day_Kind := Last_Sunday;
elsif Buffer (Field_First .. Field_Last) = "lastSat" then
Value.Day_Kind := Last_Saturday;
-- Simple numeric value.
else
Value.Day :=
Day_Number'Wide_Wide_Value
(Buffer (Field_First .. Field_Last));
end if;
end if;
-- Time component.
Parse_Field;
if Field_First <= Field_Last then
Parse_Time
(Value.Hour, Value.Minute, Value.Second, Value.Time_Kind);
end if;
end Parse_Zone_Common;
begin
Ada.Wide_Wide_Text_IO.Open
(File,
Ada.Wide_Wide_Text_IO.In_File,
File_Name.To_UTF_8_String,
"wcem=8");
while not Ada.Wide_Wide_Text_IO.End_Of_File (File) loop
Ada.Wide_Wide_Text_IO.Get_Line (File, Buffer, Last);
-- Remove comments
for J in Buffer'First .. Last loop
if Buffer (J) = '#' then
Last := J - 1;
-- Remove trailing spaces and horizontal tabulations.
for J in reverse Buffer'First .. Last loop
exit when Buffer (J) /= ' '
and Buffer (J) /= Ada.Characters.Wide_Wide_Latin_1.HT;
Last := J - 1;
end loop;
exit;
end if;
end loop;
-- Process non-empty line.
if Last >= Buffer'First then
First := Buffer'First;
if Buffer (1 .. 4) = "Rule" then
-- Rule line.
null;
elsif Buffer (1 .. 4) = "Link" then
Ada.Wide_Wide_Text_IO.Put_Line (Buffer (First .. Last));
elsif Buffer (1 .. 4) = "Zone" then
Ada.Wide_Wide_Text_IO.Put_Line (Buffer (First .. Last));
-- Zone primary line.
declare
D : TZ_Zone_Record;
begin
-- Skip record kind.
Parse_Field;
-- Parse name of timezone.
Parse_Field;
TZ.Name :=
League.Strings.To_Universal_String
(Buffer (Field_First .. Field_Last));
-- Parse common fields.
Parse_Zone_Common (D);
TZ.Records.Append (D);
end;
else
Ada.Wide_Wide_Text_IO.Put_Line (Buffer (First .. Last));
-- Zone continuation line.
declare
D : TZ_Zone_Record;
begin
-- Parse common fields.
Parse_Zone_Common (D);
TZ.Records.Append (D);
end;
end if;
end if;
end loop;
Ada.Wide_Wide_Text_IO.Close (File);
end Load_TZ_File;
-------------
-- Prepend --
-------------
procedure Prepend
(Item : in out Time_Zone_Access;
Value : Zone_Record)
is
procedure Free is
new Ada.Unchecked_Deallocation (Internal_Time_Zone, Time_Zone_Access);
Aux : Time_Zone_Access := Item;
begin
if Aux = null then
Item := new Internal_Time_Zone (1);
else
Item := new Internal_Time_Zone (Aux.Length + 1);
Item.Data (Aux.Data'First + 1 .. Aux.Data'Last + 1) := Aux.Data;
end if;
Item.Data (Item.Data'First) := Value;
Free (Aux);
end Prepend;
----------------------
-- To_Absolute_Time --
----------------------
function To_Absolute_Time
(Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Hour : Hour_Number;
Minute : Minute_Number;
Second : Second_Number) return Absolute_Time is
begin
return
Absolute_Time (Julian_Day (Year, Month, Day) - X_Open_Epoch)
* Ticks_In_Day
+ Absolute_Time (Hour) * Ticks_In_Hour
+ Absolute_Time (Minute) * Ticks_In_Minute
+ Absolute_Time (Second) * Ticks_In_Second;
end To_Absolute_Time;
----------------------
-- To_Relative_Time --
----------------------
function To_Relative_Time
(Hour : Hour_Number;
Minute : Minute_Number;
Second : Second_Number) return Relative_Time is
begin
return
Relative_Time (Hour) * Ticks_In_Hour
+ Relative_Time (Minute) * Ticks_In_Minute
+ Relative_Time (Second) * Ticks_In_Second;
end To_Relative_Time;
procedure Test
(Z : not null Time_Zone_Access;
Y : Year_Number;
M : Month_Number;
D : Day_Number;
H : Hour_Number;
N : Minute_Number;
S : Second_Number)
is
Year : Year_Number;
Month : Month_Number;
Day : Day_Number;
Hour : Hour_Number;
Minute : Minute_Number;
Second : Second_Number;
Fraction : Nano_Second_100_Number;
JDay : Julian_Day_Number;
Stamp : Absolute_Time;
begin
Stamp := Create (UTC_Time_Zone'Access, Julian_Day (Y, M, D), H, N, S, 0);
Split (UTC_Time_Zone'Access, Stamp, JDay, Hour, Minute, Second, Fraction);
Split (JDay, Year, Month, Day);
Ada.Wide_Wide_Text_IO.Put
(Ada.Strings.Wide_Wide_Fixed.Trim
(Year_Number'Wide_Wide_Image (Year), Ada.Strings.Both)
& "-"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Month_Number'Wide_Wide_Image (Month), Ada.Strings.Both)
& "-"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Day_Number'Wide_Wide_Image (Day), Ada.Strings.Both)
& " "
& Ada.Strings.Wide_Wide_Fixed.Trim
(Hour_Number'Wide_Wide_Image (Hour), Ada.Strings.Both)
& ":"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Minute_Number'Wide_Wide_Image (Minute), Ada.Strings.Both)
& ":"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Second_Number'Wide_Wide_Image (Second), Ada.Strings.Both)
& " => ");
Split (Z.all'Unchecked_Access, Stamp, JDay, Hour, Minute, Second, Fraction);
Split (JDay, Year, Month, Day);
Ada.Wide_Wide_Text_IO.Put_Line
(Ada.Strings.Wide_Wide_Fixed.Trim
(Year_Number'Wide_Wide_Image (Year), Ada.Strings.Both)
& "-"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Month_Number'Wide_Wide_Image (Month), Ada.Strings.Both)
& "-"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Day_Number'Wide_Wide_Image (Day), Ada.Strings.Both)
& " "
& Ada.Strings.Wide_Wide_Fixed.Trim
(Hour_Number'Wide_Wide_Image (Hour), Ada.Strings.Both)
& ":"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Minute_Number'Wide_Wide_Image (Minute), Ada.Strings.Both)
& ":"
& Ada.Strings.Wide_Wide_Fixed.Trim
(Second_Number'Wide_Wide_Image (Second), Ada.Strings.Both));
end Test;
From : Absolute_Time := 0;
Z : Time_Zone_Access;
begin
Load_TZ_File (League.Application.Arguments.Element (1));
-- Generate zone information.
for R of TZ.Records loop
Prepend (Z, (From, R.GMT_Offset));
Ada.Wide_Wide_Text_IO.Put_Line
(Image (From)
& ", "
& Image (R.GMT_Offset));
if R.Year /= Year_Number'Last then
From :=
To_Absolute_Time
(R.Year, R.Month, R.Day, R.Hour, R.Minute, R.Second);
case R.Time_Kind is
when Wall =>
From := From - Absolute_Time (R.GMT_Offset);
-- XXX Note: this time must be corrected according to modifier.
when Standard =>
From := From - Absolute_Time (R.GMT_Offset);
when UTC =>
null;
end case;
else
From := Absolute_Time'Last;
end if;
end loop;
-- Some tests.
Test (Z, 1879, 12, 31, 21, 29, 39);
Test (Z, 1879, 12, 31, 21, 29, 40);
Test (Z, 1916, 7, 2, 21, 29, 59);
Test (Z, 1916, 7, 2, 21, 30, 00);
Test (Z, 1917, 7, 1, 20, 29, 11);
Test (Z, 1917, 7, 1, 20, 29, 12);
Test (Z, 2011, 3, 26, 22, 59, 59);
Test (Z, 2011, 3, 26, 23, 0, 0);
end Gen_TZ;
|
libsrc/math/daimath32/c/sccz80/l_f32_f2sint.asm | ahjelm/z88dk | 640 | 244863 | <filename>libsrc/math/daimath32/c/sccz80/l_f32_f2sint.asm
SECTION code_fp_dai32
PUBLIC l_f32_f2sint
PUBLIC l_f32_f2uint
PUBLIC l_f32_f2ulong
PUBLIC l_f32_f2slong
EXTERN ___dai32_setup_single_reg
EXTERN ___dai32_return
EXTERN ___dai32_xfix
EXTERN ___dai32_fpac
l_f32_f2sint:
l_f32_f2uint:
l_f32_f2slong:
l_f32_f2ulong:
call ___dai32_setup_single_reg
call ___dai32_xfix
ld hl,(___dai32_fpac)
ld a,h
ld h,l
ld l,a
ex de,hl
ld hl,(___dai32_fpac+2)
ld a,h
ld h,l
ld l,a
ret
|
oeis/217/A217516.asm | neoneye/loda-programs | 11 | 241988 | ; A217516: Base-n state complexity of partitioned deterministic finite automaton (PDFA) for the periodic sequence (1234)*.
; 7,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9,8,5,4,9
mov $1,8
pow $1,$0
gcd $0,2
div $1,$0
sub $0,$1
add $0,5
mod $0,10
add $0,10
mod $0,10
|
aunit/aunit-run.ads | btmalone/alog | 0 | 10446 | <filename>aunit/aunit-run.ads
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- A U N I T . R U N --
-- --
-- S p e c --
-- --
-- --
-- Copyright (C) 2006-2011, AdaCore --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- --
-- --
-- --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT is maintained by AdaCore (http://www.adacore.com) --
-- --
------------------------------------------------------------------------------
with AUnit.Options;
with AUnit.Reporter;
with AUnit.Test_Results;
with AUnit.Test_Suites;
-- Framework using text reporter
package AUnit.Run is
generic
with function Suite return AUnit.Test_Suites.Access_Test_Suite;
procedure Test_Runner
(Reporter : AUnit.Reporter.Reporter'Class;
Options : AUnit.Options.AUnit_Options := AUnit.Options.Default_Options);
generic
with function Suite return AUnit.Test_Suites.Access_Test_Suite;
procedure Test_Runner_With_Results
(Reporter : AUnit.Reporter.Reporter'Class;
Results : in out AUnit.Test_Results.Result'Class;
Options : AUnit.Options.AUnit_Options := AUnit.Options.Default_Options);
-- In this version, you can pass your own Result class. In particular, this
-- can be used to extend the Result type so that for instance you can
-- output information every time a test passed or fails.
-- Results is not cleared before running the tests, this is your
-- responsibility, so that you can for instance cumulate results as needed.
generic
with function Suite return AUnit.Test_Suites.Access_Test_Suite;
function Test_Runner_With_Status
(Reporter : AUnit.Reporter.Reporter'Class;
Options : AUnit.Options.AUnit_Options := AUnit.Options.Default_Options)
return Status;
end AUnit.Run;
|
src/main/antlr/BabelParser.g4 | VinnieH/babel | 0 | 265 | <reponame>VinnieH/babel
parser grammar BabelParser;
options { tokenVocab=BabelLexer; }
@header {
import javax.annotation.Nullable;
}
expression
: (statement ';')* returnStatement ';'?
EOF;
//used in validation of text fields supplied by the user
variable_only
: variable
EOF;
statement
: assignment
;
returnStatement
: 'return'? booleanExpr
| 'return'? scalarExpr
;
assignment
: var name '=' scalarExpr
;
booleanExpr
: scalarExpr (lt | lteq | gt | gteq) scalarExpr
| scalarExpr eq scalarExpr plusMinus literal
| '(' booleanExpr ')'
;
scalarExpr
: (literal | variable)
| var '[' scalarExpr ']'
| '(' scalarExpr ')'
| (sum | prod) '(' scalarExpr ',' scalarExpr ',' lambdaExpr ')'
| binaryFunction '(' scalarExpr ',' scalarExpr ')'
| unaryFunction '(' scalarExpr ')'
| negate scalarExpr
| scalarExpr raise scalarExpr
| scalarExpr (mult | div | mod) scalarExpr
| scalarExpr (plus | minus) scalarExpr
;
lambdaExpr
locals [ @Nullable Double value = null ]
: name '->' scalarExpr
;
plus : '+';
minus : '-';
plusMinus : '+/-';
negate : '-'; //note it is legal to have to productions consuming the same token
mult : '*';
div : '/';
mod : '%';
raise : '^';
sum : 'sum';
prod : 'prod';
lt : '<';
lteq : '<=';
gt : '>';
gteq : '>=';
eq : '=' | '==' ;
var
: 'var'
;
binaryFunction
: 'max'
| 'min'
| 'log'
;
unaryFunction
: 'cos' | 'sin' | 'tan'
| 'atan' | 'acos' | 'asin'
| 'sinh' | 'cosh' | 'tanh'
| 'cot'
//override Javas default log & log10 with ln & log respectively
| 'ln' | 'log'
| 'abs'
| 'sqrt' | 'cbrt'
| 'sqr' | 'cube'
| 'ceil' | 'floor'
| 'sgn'
;
name : VARIABLE;
variable : VARIABLE;
literal : INTEGER | FLOAT | CONSTANT ;
|
src/gen/gstreamer-gst_low_level-gstreamer_0_10_gst_gstdatetime_h.ads | persan/A-gst | 1 | 17997 | <filename>src/gen/gstreamer-gst_low_level-gstreamer_0_10_gst_gstdatetime_h.ads
pragma Ada_2005;
pragma Style_Checks (Off);
pragma Warnings (Off);
with Interfaces.C; use Interfaces.C;
with System;
with glib;
with glib.Values;
with System;
with GLIB; -- with GStreamer.GST_Low_Level.glibconfig_h;
package GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstdatetime_h is
-- GStreamer
-- * Copyright (C) 2010 <NAME> <<EMAIL>>
-- *
-- * This library is free software; you can redistribute it and/or
-- * modify it under the terms of the GNU Library General Public
-- * License as published by the Free Software Foundation; either
-- * version 2 of the License, or (at your option) any later version.
-- *
-- * This library is distributed in the hope that it will be useful,
-- * but WITHOUT ANY WARRANTY; without even the implied warranty of
-- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- * Library General Public License for more details.
-- *
-- * You should have received a copy of the GNU Library General Public
-- * License along with this library; if not, write to the
-- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- * Boston, MA 02111-1307, USA.
--
--*
-- * GstDateTime:
-- *
-- * Opaque, immutable, refcounted struct that stores date, time and timezone
-- * information. It currently supports ranges from 0001-01-01 to
-- * 9999-12-31 in the Gregorian proleptic calendar.
-- *
-- * Use the acessor functions to get the stored values.
--
-- skipped empty struct u_GstDateTime
-- skipped empty struct GstDateTime
function gst_date_time_get_year (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:39
pragma Import (C, gst_date_time_get_year, "gst_date_time_get_year");
function gst_date_time_get_month (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:40
pragma Import (C, gst_date_time_get_month, "gst_date_time_get_month");
function gst_date_time_get_day (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:41
pragma Import (C, gst_date_time_get_day, "gst_date_time_get_day");
function gst_date_time_get_hour (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:42
pragma Import (C, gst_date_time_get_hour, "gst_date_time_get_hour");
function gst_date_time_get_minute (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:43
pragma Import (C, gst_date_time_get_minute, "gst_date_time_get_minute");
function gst_date_time_get_second (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:44
pragma Import (C, gst_date_time_get_second, "gst_date_time_get_second");
function gst_date_time_get_microsecond (datetime : System.Address) return GLIB.gint; -- gst/gstdatetime.h:45
pragma Import (C, gst_date_time_get_microsecond, "gst_date_time_get_microsecond");
function gst_date_time_get_time_zone_offset (datetime : System.Address) return GLIB.gfloat; -- gst/gstdatetime.h:46
pragma Import (C, gst_date_time_get_time_zone_offset, "gst_date_time_get_time_zone_offset");
function gst_date_time_new_from_unix_epoch_local_time (secs : GLIB.gint64) return System.Address; -- gst/gstdatetime.h:48
pragma Import (C, gst_date_time_new_from_unix_epoch_local_time, "gst_date_time_new_from_unix_epoch_local_time");
function gst_date_time_new_from_unix_epoch_utc (secs : GLIB.gint64) return System.Address; -- gst/gstdatetime.h:49
pragma Import (C, gst_date_time_new_from_unix_epoch_utc, "gst_date_time_new_from_unix_epoch_utc");
function gst_date_time_new_local_time
(year : GLIB.gint;
month : GLIB.gint;
day : GLIB.gint;
hour : GLIB.gint;
minute : GLIB.gint;
seconds : GLIB.gdouble) return System.Address; -- gst/gstdatetime.h:50
pragma Import (C, gst_date_time_new_local_time, "gst_date_time_new_local_time");
function gst_date_time_new
(tzoffset : GLIB.gfloat;
year : GLIB.gint;
month : GLIB.gint;
day : GLIB.gint;
hour : GLIB.gint;
minute : GLIB.gint;
seconds : GLIB.gdouble) return System.Address; -- gst/gstdatetime.h:54
pragma Import (C, gst_date_time_new, "gst_date_time_new");
function gst_date_time_new_now_local_time return System.Address; -- gst/gstdatetime.h:59
pragma Import (C, gst_date_time_new_now_local_time, "gst_date_time_new_now_local_time");
function gst_date_time_new_now_utc return System.Address; -- gst/gstdatetime.h:60
pragma Import (C, gst_date_time_new_now_utc, "gst_date_time_new_now_utc");
function gst_date_time_ref (datetime : System.Address) return System.Address; -- gst/gstdatetime.h:62
pragma Import (C, gst_date_time_ref, "gst_date_time_ref");
procedure gst_date_time_unref (datetime : System.Address); -- gst/gstdatetime.h:63
pragma Import (C, gst_date_time_unref, "gst_date_time_unref");
end GStreamer.GST_Low_Level.gstreamer_0_10_gst_gstdatetime_h;
|
levels/processed/lvl3_tiles.asm | cppchriscpp/ld38 | 4 | 15733 | <reponame>cppchriscpp/ld38
.export _lvl3
_lvl3:
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 66, 66
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 66, 66
.byte 5, 1, 1, 1, 1, 1, 5, 134, 5, 1, 1, 1, 1, 1, 66, 66
.byte 5, 1, 1, 1, 1, 1, 5, 134, 5, 1, 1, 1, 1, 1, 66, 66
.byte 5, 1, 1, 1, 1, 1, 5, 134, 5, 1, 1, 1, 1, 1, 66, 66
.byte 5, 1, 1, 1, 1, 1, 5, 134, 5, 1, 1, 1, 1, 1, 66, 66
.byte 5, 1, 1, 1, 1, 1, 5, 134, 5, 1, 1, 1, 1, 1, 66, 66
.byte 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 131, 131
.byte 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 131, 131
.byte 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 66, 66
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 66, 66
; Sprites
.byte 51, 1, 59, 2, 99, 2, 146, 2, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.include "levels/position_overrides/lvl3_2_1.asm"
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 105, 1, 104, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 105, 1, 1, 1, 104, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 105, 1, 1, 1, 104, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 105, 1, 1, 1, 104, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 105, 1, 1, 1, 1, 104, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 104, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 104, 66, 66, 66, 66
; Sprites
.byte 88, 6, 152, 7, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 66, 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 104, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 104, 66, 66, 66, 66
.byte 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 104, 66, 66, 66
.byte 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 104, 66, 66, 66
.byte 66, 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 104, 66, 66, 66
.byte 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
.byte 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
.byte 131, 131, 131, 131, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
.byte 131, 131, 131, 131, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
.byte 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
.byte 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
.byte 66, 66, 66, 105, 1, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66
; Sprites
.byte 54, 4, 58, 4, 120, 4, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 93, 93, 93, 93, 24, 24, 24, 24, 24, 24, 24, 24, 93, 93, 93, 93
.byte 93, 93, 93, 93, 27, 27, 27, 27, 27, 27, 27, 27, 93, 93, 93, 93
.byte 66, 66, 66, 66, 1, 1, 1, 1, 1, 1, 1, 1, 66, 66, 66, 66
.byte 66, 66, 66, 66, 106, 106, 1, 1, 1, 1, 106, 106, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 106, 132, 132, 106, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 132, 132, 66, 66, 66, 66, 66, 66, 66
.byte 107, 107, 107, 107, 107, 107, 107, 132, 132, 107, 107, 107, 107, 107, 107, 107
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5
; Sprites
.byte 39, 0, 54, 4, 57, 4, 116, 3, 122, 3, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 5, 5, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 5, 5, 5
.byte 5, 5, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 32, 36, 36
.byte 5, 5, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 34, 32, 32, 32
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 34, 32, 32
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 34, 32, 32
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 34, 32, 32
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 34, 32, 32
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 34, 32, 32
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 34, 32, 32
.byte 5, 5, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 32, 32
.byte 5, 5, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
.byte 5, 5, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
; Sprites
.byte 71, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
; Sprites
.byte 131, 3, 140, 3, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
.byte 1, 1, 1, 1, 104, 106, 106, 106, 106, 106, 106, 105, 1, 1, 1, 1
.byte 1, 1, 1, 1, 104, 66, 107, 107, 107, 107, 66, 105, 1, 1, 1, 1
.byte 1, 1, 1, 1, 104, 66, 1, 1, 1, 1, 66, 105, 1, 1, 1, 1
.byte 1, 1, 1, 1, 104, 66, 1, 1, 1, 1, 66, 105, 1, 1, 1, 1
.byte 1, 1, 1, 1, 104, 66, 106, 132, 132, 106, 66, 105, 1, 1, 1, 1
.byte 1, 1, 1, 1, 107, 107, 107, 132, 132, 107, 107, 105, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 51, 3, 60, 3, 72, 0, 115, 3, 124, 3, 133, 3, 138, 3, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.include "levels/position_overrides/lvl3_4_3.asm"
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106
.byte 106, 106, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 107
.byte 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 5, 5, 5, 5, 1, 1, 1, 1, 5, 5, 5
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
; Sprites
.byte 129, 2, 135, 3, 140, 2, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 5
.byte 5, 5, 5, 5, 5, 134, 134, 134, 134, 134, 5, 5, 5, 5, 5, 5
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 5, 5, 5, 5, 5, 134, 134, 135, 134, 134, 5, 5, 5, 5, 5, 5
.byte 5, 5, 5, 5, 5, 134, 134, 143, 134, 134, 5, 5, 5, 5, 5, 5
.byte 1, 1, 26, 24, 25, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5
.byte 1, 1, 26, 24, 25, 1, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5
.byte 1, 1, 26, 24, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 5, 5
.byte 1, 1, 26, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 5, 5
.byte 1, 1, 26, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 5, 5
.byte 1, 1, 26, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 5, 5
.byte 1, 1, 5, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 106
.byte 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66
.byte 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5
.byte 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 5
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
.byte 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5
; Sprites
.byte 114, 2, 122, 2, 133, 2, 135, 2, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 106, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 66, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
.byte 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
; Sprites
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
.byte 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
; End sprite data
;Overrides
.byte $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0, $f0
.byte 0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0,0, 0, 0, 0
; No last room because rom space |
Transynther/x86/_processed/NONE/_un_xt_sm_/i7-7700_9_0xca.log_21829_1756.asm | ljhsiun2/medusa | 9 | 95175 | <filename>Transynther/x86/_processed/NONE/_un_xt_sm_/i7-7700_9_0xca.log_21829_1756.asm<gh_stars>1-10
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r14
push %r8
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x3e4a, %rcx
nop
cmp $44812, %r14
mov $0x6162636465666768, %rax
movq %rax, %xmm1
vmovups %ymm1, (%rcx)
nop
cmp $50735, %rcx
lea addresses_WT_ht+0xe84a, %rsi
lea addresses_D_ht+0x11d4a, %rdi
nop
nop
add $13688, %rbx
mov $91, %rcx
rep movsb
nop
nop
nop
nop
add %rax, %rax
lea addresses_normal_ht+0x1ed4a, %rsi
lea addresses_WT_ht+0x105ca, %rdi
nop
nop
dec %r12
mov $21, %rcx
rep movsq
nop
nop
nop
nop
xor %rcx, %rcx
lea addresses_WC_ht+0x34a, %rsi
lea addresses_A_ht+0xac2e, %rdi
sub $9754, %rbx
mov $97, %rcx
rep movsb
nop
nop
and %r12, %r12
lea addresses_D_ht+0x214a, %rsi
lea addresses_D_ht+0x8c4a, %rdi
nop
nop
nop
nop
nop
cmp $64127, %r8
mov $95, %rcx
rep movsq
nop
nop
nop
cmp %r12, %r12
lea addresses_WC_ht+0x1ee6a, %rsi
lea addresses_UC_ht+0x1154a, %rdi
clflush (%rsi)
nop
nop
nop
and %r14, %r14
mov $126, %rcx
rep movsl
sub %r14, %r14
lea addresses_D_ht+0x454a, %r12
nop
nop
nop
nop
cmp %rsi, %rsi
movups (%r12), %xmm3
vpextrq $1, %xmm3, %r8
nop
cmp $46549, %r14
lea addresses_WC_ht+0x1404a, %r12
nop
cmp %rsi, %rsi
movups (%r12), %xmm6
vpextrq $0, %xmm6, %rbx
nop
nop
add $38609, %rdi
lea addresses_WC_ht+0xdd3a, %rdi
nop
nop
nop
nop
and $29302, %r14
movb $0x61, (%rdi)
cmp %rdi, %rdi
lea addresses_WC_ht+0xe42a, %rsi
lea addresses_A_ht+0x2d0a, %rdi
nop
nop
nop
nop
sub $45170, %rbx
mov $77, %rcx
rep movsb
nop
nop
nop
nop
nop
and $43428, %rax
lea addresses_WC_ht+0x1b8a0, %rbx
nop
nop
add %r12, %r12
movl $0x61626364, (%rbx)
nop
nop
add %rcx, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r8
pop %r14
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r14
push %r15
push %r8
push %r9
push %rdi
// Store
lea addresses_WT+0xdd4a, %rdi
nop
nop
nop
cmp $6030, %r15
mov $0x5152535455565758, %r12
movq %r12, %xmm1
movups %xmm1, (%rdi)
nop
inc %r15
// Faulty Load
lea addresses_WT+0xdd4a, %r13
nop
nop
nop
nop
nop
inc %r14
mov (%r13), %r8d
lea oracles, %r13
and $0xff, %r8
shlq $12, %r8
mov (%r13,%r8,1), %r8
pop %rdi
pop %r9
pop %r8
pop %r15
pop %r14
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 16, 'NT': False, 'type': 'addresses_WT'}}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 4, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'congruent': 8, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_normal_ht'}}
{'src': {'congruent': 8, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'congruent': 8, 'same': False, 'type': 'addresses_D_ht'}}
{'src': {'congruent': 11, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'dst': {'congruent': 6, 'same': False, 'type': 'addresses_WT_ht'}}
{'src': {'congruent': 9, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 1, 'same': False, 'type': 'addresses_A_ht'}}
{'src': {'congruent': 10, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'congruent': 5, 'same': False, 'type': 'addresses_D_ht'}}
{'src': {'congruent': 4, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 11, 'same': False, 'type': 'addresses_UC_ht'}}
{'src': {'congruent': 11, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 7, 'AVXalign': False, 'same': True, 'size': 16, 'NT': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_WC_ht'}}
{'src': {'congruent': 5, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 6, 'same': False, 'type': 'addresses_A_ht'}}
{'OP': 'STOR', 'dst': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_WC_ht'}}
{'79': 16, '5f': 5, '58': 21808}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 79 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 79 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
|
anagram-generator-ada/src/scramble.adb | jnguyen1098/legacy-software | 1 | 8434 | -----------------------------------------------------------------------
-- Word Scrambler --
-- By: <NAME> (XXXXXXX) --
-----------------------------------------------------------------------
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Numerics.Discrete_Random;
with Ada.Characters.Handling; use Ada.Characters.Handling;
with Ada.Directories; use Ada.Directories;
procedure Scramble is
-------------------------- Main Subprograms ---------------------------
procedure getFilename(File_Name : out String; Len : out Integer);
function processText(File_Name : String) return Integer;
procedure scrambleWord(Str : in out String);
function randomInt(A : Integer; B : Integer) return Integer;
function isWord(Str : String) return Boolean;
-----------------------------------------------------------------------
-- Verifies a filename and returns it to main
procedure getFilename(File_Name : out String; Len : out Integer) is
begin
File_Name_Check: loop
-- Prompt user for filename
Put("File name to open: ");
Get_Line(File_Name, Len);
-- Filename testing. Assumed to ask again if loop doesn't break
if (File_Name(File_Name'First .. Len) = "" or else
File_Name(File_Name'First .. File_Name'First) = "." or else
File_Name(File_Name'First .. File_Name'First) = "/" or else
exists(File_Name(File_Name'First .. Len)) = False) then
Put_Line("Could not open file! Re-try.");
New_Line;
-- Loop will break and function will exit assuming all tests pass
else exit File_Name_Check;
end if;
end loop File_Name_Check;
end getFilename;
-----------------------------------------------------------------------
-- Processes the words within a file
function processText(File_Name : String) return Integer is
Word_Count : Integer := 0;
Fp : Ada.Text_IO.File_Type;
begin
-- Open the file for playback
Open(File => Fp,
Mode => In_File,
Name => File_Name);
-- Print every original line
Put_Line(" O r i g i n a l T e x t");
Put_Line("--------------------------------------------------" &
"----------------------");
while not End_Of_File(Fp) loop
Put_Line(Get_Line(Fp));
end loop;
New_Line;
Close(Fp);
-- Attempt to open the file again, this time for processing
Open(File => Fp,
Mode => In_File,
Name => File_Name);
-- Process file by iterating over every line
Put_Line(" T r a n s p o s e d T e x t");
Put_Line("--------------------------------------------------" &
"----------------------");
-- Like above, we iterate over the file
while not End_Of_File(Fp) loop
declare
-- Left and Right represent slice/substring indices for parsing
-- Line is the fixed string holding the line. Because it is within
-- block scope with the loop, we do not have to use unbounded
-- string. This is because we re-create it every loop iteration.
Left : Integer := 1;
Right : Integer := 1;
Line : String := Get_Line(Fp);
begin
-- Parsing algorithm that aims to 'greedily' select the largest
-- word using Left and Right to index potential substrings, and
-- then moving to the next potential candidate.
-- This algorithm will backtrack upon discovering a non-alpha
-- character and use the backtracked 'word' as the scramble target.
-- Otherwise, it will just print out, one-by-one, as many non-
-- alpha characters as possible before returning to the greedy
-- word building algorithm as mentioned earlier.
-- This algorithm, as shown in this while loop, will only run for
-- the length of the current line. This is for bounds-checking.
while Left <= Line'Length and then Right <= Line'Length loop
-- If current substring is a word...
if isWord(Line(Left .. Right)) then
-- ...then greedily grow it until it is no longer a word.
while Right <= Line'Length and then
isWord(Line(Left .. Right)) loop
Right := Right + 1;
end loop;
-- Upon finding a non-alpha character, we backtrack 1
Right := Right - 1;
-- We know that this backtracked word is the largest
-- possible substring that satisfies isWord(), so we go on
-- to scramble it in-place and then print it.
scrambleWord(Line(Left .. Right));
Put(Line(Left .. Right));
-- In doing so, we increment the word count.
Word_Count := Word_Count + 1;
-- Then, we set both Left and Right indices into the first
-- character following the word we just scrambled.
Right := Right + 1;
Left := Right;
-- Otherwise, if the current substring is NOT a word...
else
-- ...we don't want to do anything else but print it.
Put(Line(Left .. Right));
-- In fact, we print AS MANY non-alphabetic characters as
-- possible. As long as there are more, it will always
-- fall back to this else statement.
Left := Left + 1;
Right := Right + 1;
end if;
end loop; -- We are finished parsing the file
New_Line; -- Putting a new line for cleanliness
end; -- End loop scope
end loop; -- End the actual loop
-- Close the file when we are done and return word count
Close(Fp);
return Word_Count;
end processText;
-----------------------------------------------------------------------
-- Scramble a string / "word" in-place
procedure scrambleWord(Str : in out String) is
-- Copies the string not including first/last char.
Copy : String := Str(Str'First + 1 .. Str'Last - 1);
Rand : Integer;
begin
-- Only words 4 char. or greater will be scrambled
if Str'Length > 3 then
-- Iterate over the middle characters
for i in 2 .. Str'Length - 1 loop
-- Keep looping until we get a unique letter
loop
Rand := randomInt(A => Copy'First, B => Copy'Last + 1);
exit when Copy(Rand) /= '.';
end loop;
-- Copy this character over to the scrambled word
Str(Str'First + i - 1) := Copy(Rand);
-- Mark the original character spot as "used".
-- This method only works because only true words
-- are passed to scrambleWord().
Copy(Rand) := '.';
end loop;
end if;
end scrambleWord;
-----------------------------------------------------------------------
-- Check if a string is completely alphabetic
function isWord(Str : String) return Boolean is
begin
-- Check for empty string
if Str = "" then
return False;
end if;
-- Check if each character is alphabetic
for i in Str'First .. Str'Last loop
if not Is_Letter(Str(i)) then
return False;
end if;
end loop;
-- If we reach this point, it's a good string and we exit
return true;
end isWord;
-----------------------------------------------------------------------
-- Generate a random number on the interval [A, B) (incl. - excl.)
function randomInt(A : Integer; B : Integer) return Integer is
subtype IntGen is Integer range A .. B - 1;
package RandGen is new Ada.Numerics.Discrete_Random (IntGen);
use RandGen;
RandIntGen : Generator;
begin
-- Generate our number
Reset(RandIntGen);
return Random(RandIntGen);
end randomInt;
------------------------------ Variables ------------------------------
File_Name_Len : Integer;
File_Name : String(1..5000);
Num_Words : Integer;
-------------------------------- Main ---------------------------------
begin
getFilename(File_Name, File_Name_Len);
New_Line;
Num_Words := processText(File_Name(1..File_Name_Len));
New_Line;
Put_Line("Word count: " & Integer'Image(Num_Words));
end Scramble;
-----------------------------------------------------------------------
|
libsrc/_DEVELOPMENT/target/zxn/zxn_crt.asm | jpoikela/z88dk | 38 | 80736 | <reponame>jpoikela/z88dk<filename>libsrc/_DEVELOPMENT/target/zxn/zxn_crt.asm
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; SELECT CRT0 FROM -STARTUP=N COMMANDLINE OPTION ;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF !DEFINED_startup
defc DEFINED_startup = 1
defc startup = 0
IFNDEF startup
ENDIF
ENDIF
IFNDEF startup
; startup undefined so select a default
defc startup = 0
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; user supplied crt ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; zx next ram model ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; standard 32 column display
;
; stdin = zx_01_input_kbd_inkey
; stdout = zx_01_output_char_32 full screen
; stderr = dup(stdout)
IFNDEF __CRTCFG
defc __CRTCFG = 0
ENDIF
IFNDEF __MMAP
defc __MMAP = 0
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; zx next ram model ;;
;; generated by target/zxn/startup/zxn_crt_0.m4 ;;
;; ;;
;; 48k memory model (flat 64k address space) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; GLOBAL SYMBOLS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "config_zxn_public.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CRT AND CLIB CONFIGURATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "../crt_defaults.inc"
include "crt_config.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; crt rules ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IFDEF CRT_ORG_CODE
defc __crt_org_code = CRT_ORG_CODE
ELSE
IFDEF TAR__crt_org_code
defc __crt_org_code = TAR__crt_org_code
ELSE
defc __crt_org_code = DEF__crt_org_code
ENDIF
ENDIF
IFDEF REGISTER_SP
defc __register_sp = REGISTER_SP
ELSE
IFDEF STACKPTR
defc __register_sp = STACKPTR
ELSE
IFDEF TAR__register_sp
defc __register_sp = TAR__register_sp
ELSE
defc __register_sp = DEF__register_sp
ENDIF
ENDIF
ENDIF
IFDEF CRT_STACK_SIZE
defc __crt_stack_size = CRT_STACK_SIZE
ELSE
IFDEF TAR__crt_stack_size
defc __crt_stack_size = TAR__crt_stack_size
ELSE
defc __crt_stack_size = DEF__crt_stack_size
ENDIF
ENDIF
IFDEF CRT_ORG_DATA
defc __crt_org_data = CRT_ORG_DATA
ELSE
IFDEF TAR__crt_org_data
defc __crt_org_data = TAR__crt_org_data
ELSE
defc __crt_org_data = DEF__crt_org_data
ENDIF
ENDIF
IFDEF CRT_ORG_BSS
defc __crt_org_bss = CRT_ORG_BSS
ELSE
IFDEF TAR__crt_org_bss
defc __crt_org_bss = TAR__crt_org_bss
ELSE
defc __crt_org_bss = DEF__crt_org_bss
ENDIF
ENDIF
IFDEF CRT_MODEL
defc __crt_model = CRT_MODEL
ELSE
IFDEF TAR__crt_model
defc __crt_model = TAR__crt_model
ELSE
defc __crt_model = DEF__crt_model
ENDIF
ENDIF
IFDEF CRT_INITIALIZE_BSS
defc __crt_initialize_bss = CRT_INITIALIZE_BSS
ELSE
IFDEF TAR__crt_initialize_bss
defc __crt_initialize_bss = TAR__crt_initialize_bss
ELSE
defc __crt_initialize_bss = DEF__crt_initialize_bss
ENDIF
ENDIF
IFDEF CRT_INCLUDE_PREAMBLE
defc __crt_include_preamble = CRT_INCLUDE_PREAMBLE
ELSE
IFDEF TAR__crt_include_preamble
defc __crt_include_preamble = TAR__crt_include_preamble
ELSE
defc __crt_include_preamble = DEF__crt_include_preamble
ENDIF
ENDIF
IFDEF CRT_ORG_VECTOR_TABLE
defc __crt_org_vector_table = CRT_ORG_VECTOR_TABLE
ELSE
IFDEF TAR__crt_org_vector_table
defc __crt_org_vector_table = TAR__crt_org_vector_table
ELSE
defc __crt_org_vector_table = DEF__crt_org_vector_table
ENDIF
ENDIF
IF __Z180
IFDEF CRT_IO_VECTOR_BASE
defc __crt_io_vector_base = CRT_IO_VECTOR_BASE
ELSE
IFDEF TAR__crt_io_vector_base
defc __crt_io_vector_base = TAR__crt_io_vector_base
ELSE
defc __crt_io_vector_base = DEF__crt_io_vector_base
ENDIF
ENDIF
ENDIF
IFDEF CRT_INTERRUPT_MODE
defc __crt_interrupt_mode = CRT_INTERRUPT_MODE
ELSE
IFDEF TAR__crt_interrupt_mode
defc __crt_interrupt_mode = TAR__crt_interrupt_mode
ELSE
defc __crt_interrupt_mode = DEF__crt_interrupt_mode
ENDIF
ENDIF
IFDEF CRT_INTERRUPT_MODE_EXIT
defc __crt_interrupt_mode_exit = CRT_INTERRUPT_MODE_EXIT
ELSE
IFDEF TAR__crt_interrupt_mode_exit
defc __crt_interrupt_mode_exit = TAR__crt_interrupt_mode_exit
ELSE
defc __crt_interrupt_mode_exit = DEF__crt_interrupt_mode_exit
ENDIF
ENDIF
IFDEF CRT_ENABLE_COMMANDLINE
defc __crt_enable_commandline = CRT_ENABLE_COMMANDLINE
ELSE
IFDEF TAR__crt_enable_commandline
defc __crt_enable_commandline = TAR__crt_enable_commandline
ELSE
defc __crt_enable_commandline = DEF__crt_enable_commandline
ENDIF
ENDIF
IFDEF CRT_ENABLE_RESTART
defc __crt_enable_restart = CRT_ENABLE_RESTART
ELSE
IFDEF TAR__crt_enable_restart
defc __crt_enable_restart = TAR__crt_enable_restart
ELSE
defc __crt_enable_restart = DEF__crt_enable_restart
ENDIF
ENDIF
IFDEF CRT_ENABLE_CLOSE
defc __crt_enable_close = CRT_ENABLE_CLOSE
ELSE
IFDEF TAR__crt_enable_close
defc __crt_enable_close = TAR__crt_enable_close
ELSE
defc __crt_enable_close = DEF__crt_enable_close
ENDIF
ENDIF
IFDEF CRT_ENABLE_EIDI
defc __crt_enable_eidi = CRT_ENABLE_EIDI
ELSE
IFDEF TAR__crt_enable_eidi
defc __crt_enable_eidi = TAR__crt_enable_eidi
ELSE
defc __crt_enable_eidi = DEF__crt_enable_eidi
ENDIF
ENDIF
IF __crt_enable_restart
defc __crt_on_exit = 0x10008
ELSE
IFDEF CRT_ON_EXIT
defc __crt_on_exit = CRT_ON_EXIT
ELSE
IFDEF TAR__crt_on_exit
defc __crt_on_exit = TAR__crt_on_exit
ELSE
defc __crt_on_exit = DEF__crt_on_exit
ENDIF
ENDIF
ENDIF
IFDEF CLIB_EXIT_STACK_SIZE
defc __clib_exit_stack_size = CLIB_EXIT_STACK_SIZE
ELSE
IFDEF TAR__clib_exit_stack_size
defc __clib_exit_stack_size = TAR__clib_exit_stack_size
ELSE
defc __clib_exit_stack_size = DEF__clib_exit_stack_size
ENDIF
ENDIF
IFDEF CLIB_QUICKEXIT_STACK_SIZE
defc __clib_quickexit_stack_size = CLIB_QUICKEXIT_STACK_SIZE
ELSE
IFDEF TAR__clib_quickexit_stack_size
defc __clib_quickexit_stack_size = TAR__clib_quickexit_stack_size
ELSE
defc __clib_quickexit_stack_size = DEF__clib_quickexit_stack_size
ENDIF
ENDIF
IFDEF CLIB_MALLOC_HEAP_SIZE
defc __clib_malloc_heap_size = CLIB_MALLOC_HEAP_SIZE
ELSE
IFDEF TAR__clib_malloc_heap_size
defc __clib_malloc_heap_size = TAR__clib_malloc_heap_size
ELSE
defc __clib_malloc_heap_size = DEF__clib_malloc_heap_size
ENDIF
ENDIF
IFDEF CLIB_STDIO_HEAP_SIZE
defc __clib_stdio_heap_size = CLIB_STDIO_HEAP_SIZE
ELSE
IFDEF TAR__clib_stdio_heap_size
defc __clib_stdio_heap_size = TAR__clib_stdio_heap_size
ELSE
defc __clib_stdio_heap_size = DEF__clib_stdio_heap_size
ENDIF
ENDIF
IFDEF CLIB_BALLOC_TABLE_SIZE
defc __clib_balloc_table_size = CLIB_BALLOC_TABLE_SIZE
ELSE
IFDEF TAR__clib_balloc_table_size
defc __clib_balloc_table_size = TAR__clib_balloc_table_size
ELSE
defc __clib_balloc_table_size = DEF__clib_balloc_table_size
ENDIF
ENDIF
IFDEF CLIB_FOPEN_MAX
defc __clib_fopen_max = CLIB_FOPEN_MAX
ELSE
IFDEF TAR__clib_fopen_max
defc __clib_fopen_max = TAR__clib_fopen_max
ELSE
defc __clib_fopen_max = DEF__clib_fopen_max
ENDIF
ENDIF
IFDEF CLIB_OPEN_MAX
defc __clib_open_max = CLIB_OPEN_MAX
ELSE
IFDEF TAR__clib_open_max
defc __clib_open_max = TAR__clib_open_max
ELSE
defc __clib_open_max = DEF__clib_open_max
ENDIF
ENDIF
IFDEF CRT_ENABLE_RST
defc __crt_enable_rst = CRT_ENABLE_RST
ELSE
IFDEF TAR__crt_enable_rst
defc __crt_enable_rst = TAR__crt_enable_rst
ELSE
defc __crt_enable_rst = DEF__crt_enable_rst
ENDIF
ENDIF
IFDEF CRT_ENABLE_NMI
defc __crt_enable_nmi = CRT_ENABLE_NMI
ELSE
IFDEF TAR__crt_enable_nmi
defc __crt_enable_nmi = TAR__crt_enable_nmi
ELSE
defc __crt_enable_nmi = DEF__crt_enable_nmi
ENDIF
ENDIF
IFDEF CRT_ENABLE_TRAP
defc __crt_enable_trap = CRT_ENABLE_TRAP
ELSE
IFDEF TAR__crt_enable_trap
defc __crt_enable_trap = TAR__crt_enable_trap
ELSE
defc __crt_enable_trap = DEF__crt_enable_trap
ENDIF
ENDIF
;; rules that must be processed by m4
IFNDEF __crt_include_driver_instantiation
defc __crt_include_driver_instantiation = 0
ENDIF
;; public definitions
PUBLIC __clib_fopen_max
PUBLIC __clib_open_max
PUBLIC __exit_stack_size
PUBLIC __quickexit_stack_size
defc __exit_stack_size = __clib_exit_stack_size
defc __quickexit_stack_size = __clib_quickexit_stack_size
IF __Z180
PUBLIC __IO_VECTOR_BASE
IF __crt_io_vector_base < 0
IF (__crt_org_vector_table < 0)
IF (-__crt_org_vector_table) & 0x1f
"Cannot place __IO_VECTOR_BASE at start of interrupt vector table"
ELSE
defc __IO_VECTOR_BASE = (-__crt_org_vector_table) & 0xe0
ENDIF
ELSE
IF __crt_org_vector_table & 0x1f
"Cannot place __IO_VECTOR_BASE at start of interrupt vector table"
ELSE
defc __IO_VECTOR_BASE = __crt_org_vector_table & 0xe0
ENDIF
ENDIF
ELSE
IF __crt_io_vector_base & 0x1f
"Illegal __IO_VECTOR_BASE"
ELSE
defc __IO_VECTOR_BASE = __crt_io_vector_base & 0xe0
ENDIF
ENDIF
ENDIF
;; end crt rules ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; crt rules for zx next ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Define Memory Banks
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IFNDEF CRT_ORG_BANK_0
defc CRT_ORG_BANK_0 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_0_L
defc CRT_ORG_BANK_0_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_0_H
defc CRT_ORG_BANK_0_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_1
defc CRT_ORG_BANK_1 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_1_L
defc CRT_ORG_BANK_1_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_1_H
defc CRT_ORG_BANK_1_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_2
defc CRT_ORG_BANK_2 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_2_L
defc CRT_ORG_BANK_2_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_2_H
defc CRT_ORG_BANK_2_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_3
defc CRT_ORG_BANK_3 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_3_L
defc CRT_ORG_BANK_3_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_3_H
defc CRT_ORG_BANK_3_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_4
defc CRT_ORG_BANK_4 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_4_L
defc CRT_ORG_BANK_4_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_4_H
defc CRT_ORG_BANK_4_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_5
defc CRT_ORG_BANK_5 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_5_L
defc CRT_ORG_BANK_5_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_5_H
defc CRT_ORG_BANK_5_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_6
defc CRT_ORG_BANK_6 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_6_L
defc CRT_ORG_BANK_6_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_6_H
defc CRT_ORG_BANK_6_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_7
defc CRT_ORG_BANK_7 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_7_L
defc CRT_ORG_BANK_7_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_7_H
defc CRT_ORG_BANK_7_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_8
defc CRT_ORG_BANK_8 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_8_L
defc CRT_ORG_BANK_8_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_8_H
defc CRT_ORG_BANK_8_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_9
defc CRT_ORG_BANK_9 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_9_L
defc CRT_ORG_BANK_9_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_9_H
defc CRT_ORG_BANK_9_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_10
defc CRT_ORG_BANK_10 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_10_L
defc CRT_ORG_BANK_10_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_10_H
defc CRT_ORG_BANK_10_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_11
defc CRT_ORG_BANK_11 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_11_L
defc CRT_ORG_BANK_11_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_11_H
defc CRT_ORG_BANK_11_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_12
defc CRT_ORG_BANK_12 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_12_L
defc CRT_ORG_BANK_12_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_12_H
defc CRT_ORG_BANK_12_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_13
defc CRT_ORG_BANK_13 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_13_L
defc CRT_ORG_BANK_13_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_13_H
defc CRT_ORG_BANK_13_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_14
defc CRT_ORG_BANK_14 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_14_L
defc CRT_ORG_BANK_14_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_14_H
defc CRT_ORG_BANK_14_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_15
defc CRT_ORG_BANK_15 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_15_L
defc CRT_ORG_BANK_15_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_15_H
defc CRT_ORG_BANK_15_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_16
defc CRT_ORG_BANK_16 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_16_L
defc CRT_ORG_BANK_16_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_16_H
defc CRT_ORG_BANK_16_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_17
defc CRT_ORG_BANK_17 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_17_L
defc CRT_ORG_BANK_17_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_17_H
defc CRT_ORG_BANK_17_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_18
defc CRT_ORG_BANK_18 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_18_L
defc CRT_ORG_BANK_18_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_18_H
defc CRT_ORG_BANK_18_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_19
defc CRT_ORG_BANK_19 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_19_L
defc CRT_ORG_BANK_19_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_19_H
defc CRT_ORG_BANK_19_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_20
defc CRT_ORG_BANK_20 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_20_L
defc CRT_ORG_BANK_20_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_20_H
defc CRT_ORG_BANK_20_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_21
defc CRT_ORG_BANK_21 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_21_L
defc CRT_ORG_BANK_21_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_21_H
defc CRT_ORG_BANK_21_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_22
defc CRT_ORG_BANK_22 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_22_L
defc CRT_ORG_BANK_22_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_22_H
defc CRT_ORG_BANK_22_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_23
defc CRT_ORG_BANK_23 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_23_L
defc CRT_ORG_BANK_23_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_23_H
defc CRT_ORG_BANK_23_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_24
defc CRT_ORG_BANK_24 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_24_L
defc CRT_ORG_BANK_24_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_24_H
defc CRT_ORG_BANK_24_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_25
defc CRT_ORG_BANK_25 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_25_L
defc CRT_ORG_BANK_25_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_25_H
defc CRT_ORG_BANK_25_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_26
defc CRT_ORG_BANK_26 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_26_L
defc CRT_ORG_BANK_26_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_26_H
defc CRT_ORG_BANK_26_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_27
defc CRT_ORG_BANK_27 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_27_L
defc CRT_ORG_BANK_27_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_27_H
defc CRT_ORG_BANK_27_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_28
defc CRT_ORG_BANK_28 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_28_L
defc CRT_ORG_BANK_28_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_28_H
defc CRT_ORG_BANK_28_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_29
defc CRT_ORG_BANK_29 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_29_L
defc CRT_ORG_BANK_29_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_29_H
defc CRT_ORG_BANK_29_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_30
defc CRT_ORG_BANK_30 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_30_L
defc CRT_ORG_BANK_30_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_30_H
defc CRT_ORG_BANK_30_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_31
defc CRT_ORG_BANK_31 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_31_L
defc CRT_ORG_BANK_31_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_31_H
defc CRT_ORG_BANK_31_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_32
defc CRT_ORG_BANK_32 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_32_L
defc CRT_ORG_BANK_32_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_32_H
defc CRT_ORG_BANK_32_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_33
defc CRT_ORG_BANK_33 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_33_L
defc CRT_ORG_BANK_33_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_33_H
defc CRT_ORG_BANK_33_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_34
defc CRT_ORG_BANK_34 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_34_L
defc CRT_ORG_BANK_34_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_34_H
defc CRT_ORG_BANK_34_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_35
defc CRT_ORG_BANK_35 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_35_L
defc CRT_ORG_BANK_35_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_35_H
defc CRT_ORG_BANK_35_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_36
defc CRT_ORG_BANK_36 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_36_L
defc CRT_ORG_BANK_36_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_36_H
defc CRT_ORG_BANK_36_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_37
defc CRT_ORG_BANK_37 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_37_L
defc CRT_ORG_BANK_37_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_37_H
defc CRT_ORG_BANK_37_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_38
defc CRT_ORG_BANK_38 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_38_L
defc CRT_ORG_BANK_38_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_38_H
defc CRT_ORG_BANK_38_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_39
defc CRT_ORG_BANK_39 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_39_L
defc CRT_ORG_BANK_39_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_39_H
defc CRT_ORG_BANK_39_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_40
defc CRT_ORG_BANK_40 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_40_L
defc CRT_ORG_BANK_40_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_40_H
defc CRT_ORG_BANK_40_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_41
defc CRT_ORG_BANK_41 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_41_L
defc CRT_ORG_BANK_41_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_41_H
defc CRT_ORG_BANK_41_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_42
defc CRT_ORG_BANK_42 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_42_L
defc CRT_ORG_BANK_42_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_42_H
defc CRT_ORG_BANK_42_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_43
defc CRT_ORG_BANK_43 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_43_L
defc CRT_ORG_BANK_43_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_43_H
defc CRT_ORG_BANK_43_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_44
defc CRT_ORG_BANK_44 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_44_L
defc CRT_ORG_BANK_44_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_44_H
defc CRT_ORG_BANK_44_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_45
defc CRT_ORG_BANK_45 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_45_L
defc CRT_ORG_BANK_45_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_45_H
defc CRT_ORG_BANK_45_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_46
defc CRT_ORG_BANK_46 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_46_L
defc CRT_ORG_BANK_46_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_46_H
defc CRT_ORG_BANK_46_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_47
defc CRT_ORG_BANK_47 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_47_L
defc CRT_ORG_BANK_47_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_47_H
defc CRT_ORG_BANK_47_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_48
defc CRT_ORG_BANK_48 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_48_L
defc CRT_ORG_BANK_48_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_48_H
defc CRT_ORG_BANK_48_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_49
defc CRT_ORG_BANK_49 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_49_L
defc CRT_ORG_BANK_49_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_49_H
defc CRT_ORG_BANK_49_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_50
defc CRT_ORG_BANK_50 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_50_L
defc CRT_ORG_BANK_50_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_50_H
defc CRT_ORG_BANK_50_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_51
defc CRT_ORG_BANK_51 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_51_L
defc CRT_ORG_BANK_51_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_51_H
defc CRT_ORG_BANK_51_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_52
defc CRT_ORG_BANK_52 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_52_L
defc CRT_ORG_BANK_52_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_52_H
defc CRT_ORG_BANK_52_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_53
defc CRT_ORG_BANK_53 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_53_L
defc CRT_ORG_BANK_53_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_53_H
defc CRT_ORG_BANK_53_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_54
defc CRT_ORG_BANK_54 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_54_L
defc CRT_ORG_BANK_54_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_54_H
defc CRT_ORG_BANK_54_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_55
defc CRT_ORG_BANK_55 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_55_L
defc CRT_ORG_BANK_55_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_55_H
defc CRT_ORG_BANK_55_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_56
defc CRT_ORG_BANK_56 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_56_L
defc CRT_ORG_BANK_56_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_56_H
defc CRT_ORG_BANK_56_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_57
defc CRT_ORG_BANK_57 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_57_L
defc CRT_ORG_BANK_57_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_57_H
defc CRT_ORG_BANK_57_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_58
defc CRT_ORG_BANK_58 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_58_L
defc CRT_ORG_BANK_58_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_58_H
defc CRT_ORG_BANK_58_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_59
defc CRT_ORG_BANK_59 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_59_L
defc CRT_ORG_BANK_59_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_59_H
defc CRT_ORG_BANK_59_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_60
defc CRT_ORG_BANK_60 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_60_L
defc CRT_ORG_BANK_60_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_60_H
defc CRT_ORG_BANK_60_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_61
defc CRT_ORG_BANK_61 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_61_L
defc CRT_ORG_BANK_61_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_61_H
defc CRT_ORG_BANK_61_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_62
defc CRT_ORG_BANK_62 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_62_L
defc CRT_ORG_BANK_62_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_62_H
defc CRT_ORG_BANK_62_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_63
defc CRT_ORG_BANK_63 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_63_L
defc CRT_ORG_BANK_63_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_63_H
defc CRT_ORG_BANK_63_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_64
defc CRT_ORG_BANK_64 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_64_L
defc CRT_ORG_BANK_64_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_64_H
defc CRT_ORG_BANK_64_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_65
defc CRT_ORG_BANK_65 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_65_L
defc CRT_ORG_BANK_65_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_65_H
defc CRT_ORG_BANK_65_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_66
defc CRT_ORG_BANK_66 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_66_L
defc CRT_ORG_BANK_66_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_66_H
defc CRT_ORG_BANK_66_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_67
defc CRT_ORG_BANK_67 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_67_L
defc CRT_ORG_BANK_67_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_67_H
defc CRT_ORG_BANK_67_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_68
defc CRT_ORG_BANK_68 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_68_L
defc CRT_ORG_BANK_68_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_68_H
defc CRT_ORG_BANK_68_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_69
defc CRT_ORG_BANK_69 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_69_L
defc CRT_ORG_BANK_69_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_69_H
defc CRT_ORG_BANK_69_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_70
defc CRT_ORG_BANK_70 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_70_L
defc CRT_ORG_BANK_70_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_70_H
defc CRT_ORG_BANK_70_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_71
defc CRT_ORG_BANK_71 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_71_L
defc CRT_ORG_BANK_71_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_71_H
defc CRT_ORG_BANK_71_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_72
defc CRT_ORG_BANK_72 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_72_L
defc CRT_ORG_BANK_72_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_72_H
defc CRT_ORG_BANK_72_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_73
defc CRT_ORG_BANK_73 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_73_L
defc CRT_ORG_BANK_73_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_73_H
defc CRT_ORG_BANK_73_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_74
defc CRT_ORG_BANK_74 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_74_L
defc CRT_ORG_BANK_74_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_74_H
defc CRT_ORG_BANK_74_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_75
defc CRT_ORG_BANK_75 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_75_L
defc CRT_ORG_BANK_75_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_75_H
defc CRT_ORG_BANK_75_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_76
defc CRT_ORG_BANK_76 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_76_L
defc CRT_ORG_BANK_76_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_76_H
defc CRT_ORG_BANK_76_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_77
defc CRT_ORG_BANK_77 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_77_L
defc CRT_ORG_BANK_77_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_77_H
defc CRT_ORG_BANK_77_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_78
defc CRT_ORG_BANK_78 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_78_L
defc CRT_ORG_BANK_78_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_78_H
defc CRT_ORG_BANK_78_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_79
defc CRT_ORG_BANK_79 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_79_L
defc CRT_ORG_BANK_79_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_79_H
defc CRT_ORG_BANK_79_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_80
defc CRT_ORG_BANK_80 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_80_L
defc CRT_ORG_BANK_80_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_80_H
defc CRT_ORG_BANK_80_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_81
defc CRT_ORG_BANK_81 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_81_L
defc CRT_ORG_BANK_81_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_81_H
defc CRT_ORG_BANK_81_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_82
defc CRT_ORG_BANK_82 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_82_L
defc CRT_ORG_BANK_82_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_82_H
defc CRT_ORG_BANK_82_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_83
defc CRT_ORG_BANK_83 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_83_L
defc CRT_ORG_BANK_83_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_83_H
defc CRT_ORG_BANK_83_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_84
defc CRT_ORG_BANK_84 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_84_L
defc CRT_ORG_BANK_84_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_84_H
defc CRT_ORG_BANK_84_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_85
defc CRT_ORG_BANK_85 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_85_L
defc CRT_ORG_BANK_85_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_85_H
defc CRT_ORG_BANK_85_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_86
defc CRT_ORG_BANK_86 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_86_L
defc CRT_ORG_BANK_86_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_86_H
defc CRT_ORG_BANK_86_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_87
defc CRT_ORG_BANK_87 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_87_L
defc CRT_ORG_BANK_87_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_87_H
defc CRT_ORG_BANK_87_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_88
defc CRT_ORG_BANK_88 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_88_L
defc CRT_ORG_BANK_88_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_88_H
defc CRT_ORG_BANK_88_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_89
defc CRT_ORG_BANK_89 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_89_L
defc CRT_ORG_BANK_89_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_89_H
defc CRT_ORG_BANK_89_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_90
defc CRT_ORG_BANK_90 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_90_L
defc CRT_ORG_BANK_90_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_90_H
defc CRT_ORG_BANK_90_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_91
defc CRT_ORG_BANK_91 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_91_L
defc CRT_ORG_BANK_91_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_91_H
defc CRT_ORG_BANK_91_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_92
defc CRT_ORG_BANK_92 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_92_L
defc CRT_ORG_BANK_92_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_92_H
defc CRT_ORG_BANK_92_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_93
defc CRT_ORG_BANK_93 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_93_L
defc CRT_ORG_BANK_93_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_93_H
defc CRT_ORG_BANK_93_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_94
defc CRT_ORG_BANK_94 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_94_L
defc CRT_ORG_BANK_94_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_94_H
defc CRT_ORG_BANK_94_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_95
defc CRT_ORG_BANK_95 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_95_L
defc CRT_ORG_BANK_95_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_95_H
defc CRT_ORG_BANK_95_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_96
defc CRT_ORG_BANK_96 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_96_L
defc CRT_ORG_BANK_96_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_96_H
defc CRT_ORG_BANK_96_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_97
defc CRT_ORG_BANK_97 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_97_L
defc CRT_ORG_BANK_97_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_97_H
defc CRT_ORG_BANK_97_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_98
defc CRT_ORG_BANK_98 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_98_L
defc CRT_ORG_BANK_98_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_98_H
defc CRT_ORG_BANK_98_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_99
defc CRT_ORG_BANK_99 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_99_L
defc CRT_ORG_BANK_99_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_99_H
defc CRT_ORG_BANK_99_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_100
defc CRT_ORG_BANK_100 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_100_L
defc CRT_ORG_BANK_100_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_100_H
defc CRT_ORG_BANK_100_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_101
defc CRT_ORG_BANK_101 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_101_L
defc CRT_ORG_BANK_101_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_101_H
defc CRT_ORG_BANK_101_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_102
defc CRT_ORG_BANK_102 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_102_L
defc CRT_ORG_BANK_102_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_102_H
defc CRT_ORG_BANK_102_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_103
defc CRT_ORG_BANK_103 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_103_L
defc CRT_ORG_BANK_103_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_103_H
defc CRT_ORG_BANK_103_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_104
defc CRT_ORG_BANK_104 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_104_L
defc CRT_ORG_BANK_104_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_104_H
defc CRT_ORG_BANK_104_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_105
defc CRT_ORG_BANK_105 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_105_L
defc CRT_ORG_BANK_105_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_105_H
defc CRT_ORG_BANK_105_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_106
defc CRT_ORG_BANK_106 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_106_L
defc CRT_ORG_BANK_106_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_106_H
defc CRT_ORG_BANK_106_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_107
defc CRT_ORG_BANK_107 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_107_L
defc CRT_ORG_BANK_107_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_107_H
defc CRT_ORG_BANK_107_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_108
defc CRT_ORG_BANK_108 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_108_L
defc CRT_ORG_BANK_108_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_108_H
defc CRT_ORG_BANK_108_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_109
defc CRT_ORG_BANK_109 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_109_L
defc CRT_ORG_BANK_109_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_109_H
defc CRT_ORG_BANK_109_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_110
defc CRT_ORG_BANK_110 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_110_L
defc CRT_ORG_BANK_110_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_110_H
defc CRT_ORG_BANK_110_H = 0xe000
ENDIF
IFNDEF CRT_ORG_BANK_111
defc CRT_ORG_BANK_111 = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_111_L
defc CRT_ORG_BANK_111_L = 0xc000
ENDIF
IFNDEF CRT_ORG_BANK_111_H
defc CRT_ORG_BANK_111_H = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_0
defc CRT_ORG_PAGE_0 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_1
defc CRT_ORG_PAGE_1 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_2
defc CRT_ORG_PAGE_2 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_3
defc CRT_ORG_PAGE_3 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_4
defc CRT_ORG_PAGE_4 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_5
defc CRT_ORG_PAGE_5 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_6
defc CRT_ORG_PAGE_6 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_7
defc CRT_ORG_PAGE_7 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_8
defc CRT_ORG_PAGE_8 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_9
defc CRT_ORG_PAGE_9 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_10
defc CRT_ORG_PAGE_10 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_11
defc CRT_ORG_PAGE_11 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_12
defc CRT_ORG_PAGE_12 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_13
defc CRT_ORG_PAGE_13 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_14
defc CRT_ORG_PAGE_14 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_15
defc CRT_ORG_PAGE_15 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_16
defc CRT_ORG_PAGE_16 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_17
defc CRT_ORG_PAGE_17 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_18
defc CRT_ORG_PAGE_18 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_19
defc CRT_ORG_PAGE_19 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_20
defc CRT_ORG_PAGE_20 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_21
defc CRT_ORG_PAGE_21 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_22
defc CRT_ORG_PAGE_22 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_23
defc CRT_ORG_PAGE_23 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_24
defc CRT_ORG_PAGE_24 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_25
defc CRT_ORG_PAGE_25 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_26
defc CRT_ORG_PAGE_26 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_27
defc CRT_ORG_PAGE_27 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_28
defc CRT_ORG_PAGE_28 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_29
defc CRT_ORG_PAGE_29 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_30
defc CRT_ORG_PAGE_30 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_31
defc CRT_ORG_PAGE_31 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_32
defc CRT_ORG_PAGE_32 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_33
defc CRT_ORG_PAGE_33 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_34
defc CRT_ORG_PAGE_34 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_35
defc CRT_ORG_PAGE_35 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_36
defc CRT_ORG_PAGE_36 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_37
defc CRT_ORG_PAGE_37 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_38
defc CRT_ORG_PAGE_38 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_39
defc CRT_ORG_PAGE_39 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_40
defc CRT_ORG_PAGE_40 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_41
defc CRT_ORG_PAGE_41 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_42
defc CRT_ORG_PAGE_42 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_43
defc CRT_ORG_PAGE_43 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_44
defc CRT_ORG_PAGE_44 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_45
defc CRT_ORG_PAGE_45 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_46
defc CRT_ORG_PAGE_46 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_47
defc CRT_ORG_PAGE_47 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_48
defc CRT_ORG_PAGE_48 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_49
defc CRT_ORG_PAGE_49 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_50
defc CRT_ORG_PAGE_50 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_51
defc CRT_ORG_PAGE_51 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_52
defc CRT_ORG_PAGE_52 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_53
defc CRT_ORG_PAGE_53 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_54
defc CRT_ORG_PAGE_54 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_55
defc CRT_ORG_PAGE_55 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_56
defc CRT_ORG_PAGE_56 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_57
defc CRT_ORG_PAGE_57 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_58
defc CRT_ORG_PAGE_58 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_59
defc CRT_ORG_PAGE_59 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_60
defc CRT_ORG_PAGE_60 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_61
defc CRT_ORG_PAGE_61 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_62
defc CRT_ORG_PAGE_62 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_63
defc CRT_ORG_PAGE_63 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_64
defc CRT_ORG_PAGE_64 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_65
defc CRT_ORG_PAGE_65 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_66
defc CRT_ORG_PAGE_66 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_67
defc CRT_ORG_PAGE_67 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_68
defc CRT_ORG_PAGE_68 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_69
defc CRT_ORG_PAGE_69 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_70
defc CRT_ORG_PAGE_70 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_71
defc CRT_ORG_PAGE_71 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_72
defc CRT_ORG_PAGE_72 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_73
defc CRT_ORG_PAGE_73 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_74
defc CRT_ORG_PAGE_74 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_75
defc CRT_ORG_PAGE_75 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_76
defc CRT_ORG_PAGE_76 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_77
defc CRT_ORG_PAGE_77 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_78
defc CRT_ORG_PAGE_78 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_79
defc CRT_ORG_PAGE_79 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_80
defc CRT_ORG_PAGE_80 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_81
defc CRT_ORG_PAGE_81 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_82
defc CRT_ORG_PAGE_82 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_83
defc CRT_ORG_PAGE_83 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_84
defc CRT_ORG_PAGE_84 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_85
defc CRT_ORG_PAGE_85 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_86
defc CRT_ORG_PAGE_86 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_87
defc CRT_ORG_PAGE_87 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_88
defc CRT_ORG_PAGE_88 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_89
defc CRT_ORG_PAGE_89 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_90
defc CRT_ORG_PAGE_90 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_91
defc CRT_ORG_PAGE_91 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_92
defc CRT_ORG_PAGE_92 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_93
defc CRT_ORG_PAGE_93 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_94
defc CRT_ORG_PAGE_94 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_95
defc CRT_ORG_PAGE_95 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_96
defc CRT_ORG_PAGE_96 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_97
defc CRT_ORG_PAGE_97 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_98
defc CRT_ORG_PAGE_98 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_99
defc CRT_ORG_PAGE_99 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_100
defc CRT_ORG_PAGE_100 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_101
defc CRT_ORG_PAGE_101 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_102
defc CRT_ORG_PAGE_102 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_103
defc CRT_ORG_PAGE_103 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_104
defc CRT_ORG_PAGE_104 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_105
defc CRT_ORG_PAGE_105 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_106
defc CRT_ORG_PAGE_106 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_107
defc CRT_ORG_PAGE_107 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_108
defc CRT_ORG_PAGE_108 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_109
defc CRT_ORG_PAGE_109 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_110
defc CRT_ORG_PAGE_110 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_111
defc CRT_ORG_PAGE_111 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_112
defc CRT_ORG_PAGE_112 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_113
defc CRT_ORG_PAGE_113 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_114
defc CRT_ORG_PAGE_114 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_115
defc CRT_ORG_PAGE_115 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_116
defc CRT_ORG_PAGE_116 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_117
defc CRT_ORG_PAGE_117 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_118
defc CRT_ORG_PAGE_118 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_119
defc CRT_ORG_PAGE_119 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_120
defc CRT_ORG_PAGE_120 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_121
defc CRT_ORG_PAGE_121 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_122
defc CRT_ORG_PAGE_122 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_123
defc CRT_ORG_PAGE_123 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_124
defc CRT_ORG_PAGE_124 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_125
defc CRT_ORG_PAGE_125 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_126
defc CRT_ORG_PAGE_126 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_127
defc CRT_ORG_PAGE_127 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_128
defc CRT_ORG_PAGE_128 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_129
defc CRT_ORG_PAGE_129 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_130
defc CRT_ORG_PAGE_130 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_131
defc CRT_ORG_PAGE_131 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_132
defc CRT_ORG_PAGE_132 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_133
defc CRT_ORG_PAGE_133 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_134
defc CRT_ORG_PAGE_134 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_135
defc CRT_ORG_PAGE_135 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_136
defc CRT_ORG_PAGE_136 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_137
defc CRT_ORG_PAGE_137 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_138
defc CRT_ORG_PAGE_138 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_139
defc CRT_ORG_PAGE_139 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_140
defc CRT_ORG_PAGE_140 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_141
defc CRT_ORG_PAGE_141 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_142
defc CRT_ORG_PAGE_142 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_143
defc CRT_ORG_PAGE_143 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_144
defc CRT_ORG_PAGE_144 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_145
defc CRT_ORG_PAGE_145 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_146
defc CRT_ORG_PAGE_146 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_147
defc CRT_ORG_PAGE_147 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_148
defc CRT_ORG_PAGE_148 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_149
defc CRT_ORG_PAGE_149 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_150
defc CRT_ORG_PAGE_150 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_151
defc CRT_ORG_PAGE_151 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_152
defc CRT_ORG_PAGE_152 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_153
defc CRT_ORG_PAGE_153 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_154
defc CRT_ORG_PAGE_154 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_155
defc CRT_ORG_PAGE_155 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_156
defc CRT_ORG_PAGE_156 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_157
defc CRT_ORG_PAGE_157 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_158
defc CRT_ORG_PAGE_158 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_159
defc CRT_ORG_PAGE_159 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_160
defc CRT_ORG_PAGE_160 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_161
defc CRT_ORG_PAGE_161 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_162
defc CRT_ORG_PAGE_162 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_163
defc CRT_ORG_PAGE_163 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_164
defc CRT_ORG_PAGE_164 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_165
defc CRT_ORG_PAGE_165 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_166
defc CRT_ORG_PAGE_166 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_167
defc CRT_ORG_PAGE_167 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_168
defc CRT_ORG_PAGE_168 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_169
defc CRT_ORG_PAGE_169 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_170
defc CRT_ORG_PAGE_170 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_171
defc CRT_ORG_PAGE_171 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_172
defc CRT_ORG_PAGE_172 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_173
defc CRT_ORG_PAGE_173 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_174
defc CRT_ORG_PAGE_174 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_175
defc CRT_ORG_PAGE_175 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_176
defc CRT_ORG_PAGE_176 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_177
defc CRT_ORG_PAGE_177 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_178
defc CRT_ORG_PAGE_178 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_179
defc CRT_ORG_PAGE_179 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_180
defc CRT_ORG_PAGE_180 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_181
defc CRT_ORG_PAGE_181 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_182
defc CRT_ORG_PAGE_182 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_183
defc CRT_ORG_PAGE_183 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_184
defc CRT_ORG_PAGE_184 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_185
defc CRT_ORG_PAGE_185 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_186
defc CRT_ORG_PAGE_186 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_187
defc CRT_ORG_PAGE_187 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_188
defc CRT_ORG_PAGE_188 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_189
defc CRT_ORG_PAGE_189 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_190
defc CRT_ORG_PAGE_190 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_191
defc CRT_ORG_PAGE_191 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_192
defc CRT_ORG_PAGE_192 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_193
defc CRT_ORG_PAGE_193 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_194
defc CRT_ORG_PAGE_194 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_195
defc CRT_ORG_PAGE_195 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_196
defc CRT_ORG_PAGE_196 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_197
defc CRT_ORG_PAGE_197 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_198
defc CRT_ORG_PAGE_198 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_199
defc CRT_ORG_PAGE_199 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_200
defc CRT_ORG_PAGE_200 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_201
defc CRT_ORG_PAGE_201 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_202
defc CRT_ORG_PAGE_202 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_203
defc CRT_ORG_PAGE_203 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_204
defc CRT_ORG_PAGE_204 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_205
defc CRT_ORG_PAGE_205 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_206
defc CRT_ORG_PAGE_206 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_207
defc CRT_ORG_PAGE_207 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_208
defc CRT_ORG_PAGE_208 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_209
defc CRT_ORG_PAGE_209 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_210
defc CRT_ORG_PAGE_210 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_211
defc CRT_ORG_PAGE_211 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_212
defc CRT_ORG_PAGE_212 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_213
defc CRT_ORG_PAGE_213 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_214
defc CRT_ORG_PAGE_214 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_215
defc CRT_ORG_PAGE_215 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_216
defc CRT_ORG_PAGE_216 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_217
defc CRT_ORG_PAGE_217 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_218
defc CRT_ORG_PAGE_218 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_219
defc CRT_ORG_PAGE_219 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_220
defc CRT_ORG_PAGE_220 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_221
defc CRT_ORG_PAGE_221 = 0xe000
ENDIF
IFNDEF CRT_ORG_PAGE_222
defc CRT_ORG_PAGE_222 = 0xc000
ENDIF
IFNDEF CRT_ORG_PAGE_223
defc CRT_ORG_PAGE_223 = 0xe000
ENDIF
IFNDEF CRT_ORG_DIV_0
defc CRT_ORG_DIV_0 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_1
defc CRT_ORG_DIV_1 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_2
defc CRT_ORG_DIV_2 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_3
defc CRT_ORG_DIV_3 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_4
defc CRT_ORG_DIV_4 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_5
defc CRT_ORG_DIV_5 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_6
defc CRT_ORG_DIV_6 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_7
defc CRT_ORG_DIV_7 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_8
defc CRT_ORG_DIV_8 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_9
defc CRT_ORG_DIV_9 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_10
defc CRT_ORG_DIV_10 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_11
defc CRT_ORG_DIV_11 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_12
defc CRT_ORG_DIV_12 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_13
defc CRT_ORG_DIV_13 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_14
defc CRT_ORG_DIV_14 = 0x2000
ENDIF
IFNDEF CRT_ORG_DIV_15
defc CRT_ORG_DIV_15 = 0x2000
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ESXDOS dotx commands
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IFNDEF CRT_ORG_DTX
defc CRT_ORG_DTX = 0x8000
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; NextOS dotn commands
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PUBLIC DOTN_MAIN_OVERLAY_MASK
PUBLIC DOTN_MAIN_ABSOLUTE_MASK
IFNDEF CRT_ORG_MAIN
defc CRT_ORG_MAIN = 0x8000
ENDIF
IFNDEF DOTN_REGISTER_SP
defc DOTN_REGISTER_SP = 0x4000
ENDIF
IFNDEF DOTN_LAST_PAGE
defc DOTN_LAST_PAGE = __ZXNEXT_LAST_PAGE
ENDIF
IFNDEF DOTN_EXTRA_PAGES
defc DOTN_EXTRA_PAGES = 0
ENDIF
IFNDEF DOTN_MAIN_OVERLAY_MASK
defc DOTN_MAIN_OVERLAY_MASK = 0
ENDIF
IFNDEF DOTN_MAIN_ABSOLUTE_MASK
defc DOTN_MAIN_ABSOLUTE_MASK = 0
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Input Terminal Settings
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IFNDEF CRT_ITERM_TERMINAL_FLAGS
defc CRT_ITERM_TERMINAL_FLAGS = 0x03b0
ENDIF
; buffer size must be available to m4 (requires special case in zcc)
IFNDEF CRT_ITERM_EDIT_BUFFER_SIZE
defc CRT_ITERM_EDIT_BUFFER_SIZE = 64
ENDIF
;
; LASTK Input Terminal Only
;
IFNDEF CRT_ITERM_LASTK_ADDRESS
defc CRT_ITERM_LASTK_ADDRESS = 23560
ENDIF
;
; INKEY Input Terminal Only (used by supplied CRTs)
;
IFNDEF CRT_ITERM_INKEY_DEBOUNCE
defc CRT_ITERM_INKEY_DEBOUNCE = 1
ENDIF
IFNDEF CRT_ITERM_INKEY_REPEAT_START
defc CRT_ITERM_INKEY_REPEAT_START = 500
ENDIF
IFNDEF CRT_ITERM_INKEY_REPEAT_RATE
defc CRT_ITERM_INKEY_REPEAT_RATE = 15
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Output Terminal Settings
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IFNDEF CRT_OTERM_TERMINAL_FLAGS
defc CRT_OTERM_TERMINAL_FLAGS = 0x2370
ENDIF
;
; Terminal Window Dimensions in Characters
;
IFNDEF CRT_OTERM_WINDOW_X
defc CRT_OTERM_WINDOW_X = 0 ; multiplied by two in 64 col terminals
ENDIF
IFNDEF CRT_OTERM_WINDOW_WIDTH
defc CRT_OTERM_WINDOW_WIDTH = 32 ; multiplied by two in 64 col terminals
ENDIF
IFNDEF CRT_OTERM_WINDOW_Y
defc CRT_OTERM_WINDOW_Y = 0
ENDIF
IFNDEF CRT_OTERM_WINDOW_HEIGHT
defc CRT_OTERM_WINDOW_HEIGHT = 24
ENDIF
;
; Terminal Window Dimensions in Characters for Timex Hi-Res
;
IFNDEF CRT_OTERM_TSHR_WINDOW_X
defc CRT_OTERM_TSHR_WINDOW_X = 0 ; multiplied by two in 128 col terminals
ENDIF
IFNDEF CRT_OTERM_TSHR_WINDOW_WIDTH
defc CRT_OTERM_TSHR_WINDOW_WIDTH = 64 ; multiplied by two in 128 col terminals
ENDIF
IFNDEF CRT_OTERM_TSHR_WINDOW_Y
defc CRT_OTERM_TSHR_WINDOW_Y = 0
ENDIF
IFNDEF CRT_OTERM_TSHR_WINDOW_HEIGHT
defc CRT_OTERM_TSHR_WINDOW_HEIGHT = 24
ENDIF
;
; Terminal Text Colour
;
IFNDEF CRT_OTERM_TEXT_COLOR
defc CRT_OTERM_TEXT_COLOR = 0x38
ENDIF
IFNDEF CRT_OTERM_TEXT_COLOR_MASK
defc CRT_OTERM_TEXT_COLOR_MASK = 0x00
ENDIF
IFNDEF CRT_OTERM_BACKGROUND_COLOR
defc CRT_OTERM_BACKGROUND_COLOR = 0x38
ENDIF
;
; FZX Proportional Font Output Terminals
;
; The terminal window contains the paper into
; which fzx characters are drawn
IFNDEF CRT_OTERM_FZX_PAPER_X
defc CRT_OTERM_FZX_PAPER_X = 0
ENDIF
IFNDEF CRT_OTERM_FZX_PAPER_WIDTH
defc CRT_OTERM_FZX_PAPER_WIDTH = 256
ENDIF
IFNDEF CRT_OTERM_FZX_PAPER_Y
defc CRT_OTERM_FZX_PAPER_Y = 0
ENDIF
IFNDEF CRT_OTERM_FZX_PAPER_HEIGHT
defc CRT_OTERM_FZX_PAPER_HEIGHT = 192
ENDIF
; The terminal window for Timex Hi-Res
IFNDEF CRT_OTERM_FZX_TSHR_PAPER_X
defc CRT_OTERM_FZX_TSHR_PAPER_X = 0
ENDIF
IFNDEF CRT_OTERM_FZX_TSHR_PAPER_WIDTH
defc CRT_OTERM_FZX_TSHR_PAPER_WIDTH = 512
ENDIF
IFNDEF CRT_OTERM_FZX_TSHR_PAPER_Y
defc CRT_OTERM_FZX_TSHR_PAPER_Y = 0
ENDIF
IFNDEF CRT_OTERM_FZX_TSHR_PAPER_HEIGHT
defc CRT_OTERM_FZX_TSHR_PAPER_HEIGHT = 192
ENDIF
; draw mode must be available to m4 (requires special case in zcc)
; 0 = OR, 1 = XOR, 2 = CLEAR
IFNDEF CRT_OTERM_FZX_DRAW_MODE
defc CRT_OTERM_FZX_DRAW_MODE = 1
ENDIF
; 0 = single, 1 = 1.5, 2 = double
IFNDEF CRT_OTERM_FZX_LINE_SPACING
defc CRT_OTERM_FZX_LINE_SPACING = 0
ENDIF
; left margin in pixels to allow kerning
IFNDEF CRT_OTERM_FZX_LEFT_MARGIN
defc CRT_OTERM_FZX_LEFT_MARGIN = 3
ENDIF
; space character width expansion in pixels
IFNDEF CRT_OTERM_FZX_SPACE_EXPAND
defc CRT_OTERM_FZX_SPACE_EXPAND = 0
ENDIF
;
; FONT SELECTION
; use pragam redirect to change font
;
; #pragam redirect CRT_OTERM_FONT_8X8 = _font_8x8_rom ; 32-col font definition in rom
; #pragma redirect CRT_OTERM_FONT_8X8 = _font_8x8_zx_system ; 32-col font, timex hi-res 64-col font
; #pragma redirect CRT_OTERM_FONT_4X8 = _font_4x8_default ; 64-col font, timex hi-res 128-col font
; #pragma redirect CRT_OTERM_FONT_FZX = _ff_ind_Termino ; fzx proportional font
;; end crt rules ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SET UP MEMORY MODEL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; memory map ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __MMAP = -1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; user supplied memory map ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION UNASSIGNED
org 0
ENDIF
IF __MMAP = 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; standard CODE/DATA/BSS memory map ;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
INCLUDE "../crt_memory_model_z80.inc"
SECTION BANK_0
org CRT_ORG_BANK_0
SECTION BANK_0_L
org CRT_ORG_BANK_0_L
SECTION BANK_0_H
org CRT_ORG_BANK_0_H
SECTION BANK_1
org CRT_ORG_BANK_1
SECTION BANK_1_L
org CRT_ORG_BANK_1_L
SECTION BANK_1_H
org CRT_ORG_BANK_1_H
SECTION BANK_2
org CRT_ORG_BANK_2
SECTION BANK_2_L
org CRT_ORG_BANK_2_L
SECTION BANK_2_H
org CRT_ORG_BANK_2_H
SECTION BANK_3
org CRT_ORG_BANK_3
SECTION BANK_3_L
org CRT_ORG_BANK_3_L
SECTION BANK_3_H
org CRT_ORG_BANK_3_H
SECTION BANK_4
org CRT_ORG_BANK_4
SECTION BANK_4_L
org CRT_ORG_BANK_4_L
SECTION BANK_4_H
org CRT_ORG_BANK_4_H
SECTION BANK_5
org CRT_ORG_BANK_5
SECTION BANK_5_L
org CRT_ORG_BANK_5_L
SECTION BANK_5_H
org CRT_ORG_BANK_5_H
SECTION BANK_6
org CRT_ORG_BANK_6
SECTION BANK_6_L
org CRT_ORG_BANK_6_L
SECTION BANK_6_H
org CRT_ORG_BANK_6_H
SECTION BANK_7
org CRT_ORG_BANK_7
SECTION BANK_7_L
org CRT_ORG_BANK_7_L
SECTION BANK_7_H
org CRT_ORG_BANK_7_H
SECTION BANK_8
org CRT_ORG_BANK_8
SECTION BANK_8_L
org CRT_ORG_BANK_8_L
SECTION BANK_8_H
org CRT_ORG_BANK_8_H
SECTION BANK_9
org CRT_ORG_BANK_9
SECTION BANK_9_L
org CRT_ORG_BANK_9_L
SECTION BANK_9_H
org CRT_ORG_BANK_9_H
SECTION BANK_10
org CRT_ORG_BANK_10
SECTION BANK_10_L
org CRT_ORG_BANK_10_L
SECTION BANK_10_H
org CRT_ORG_BANK_10_H
SECTION BANK_11
org CRT_ORG_BANK_11
SECTION BANK_11_L
org CRT_ORG_BANK_11_L
SECTION BANK_11_H
org CRT_ORG_BANK_11_H
SECTION BANK_12
org CRT_ORG_BANK_12
SECTION BANK_12_L
org CRT_ORG_BANK_12_L
SECTION BANK_12_H
org CRT_ORG_BANK_12_H
SECTION BANK_13
org CRT_ORG_BANK_13
SECTION BANK_13_L
org CRT_ORG_BANK_13_L
SECTION BANK_13_H
org CRT_ORG_BANK_13_H
SECTION BANK_14
org CRT_ORG_BANK_14
SECTION BANK_14_L
org CRT_ORG_BANK_14_L
SECTION BANK_14_H
org CRT_ORG_BANK_14_H
SECTION BANK_15
org CRT_ORG_BANK_15
SECTION BANK_15_L
org CRT_ORG_BANK_15_L
SECTION BANK_15_H
org CRT_ORG_BANK_15_H
SECTION BANK_16
org CRT_ORG_BANK_16
SECTION BANK_16_L
org CRT_ORG_BANK_16_L
SECTION BANK_16_H
org CRT_ORG_BANK_16_H
SECTION BANK_17
org CRT_ORG_BANK_17
SECTION BANK_17_L
org CRT_ORG_BANK_17_L
SECTION BANK_17_H
org CRT_ORG_BANK_17_H
SECTION BANK_18
org CRT_ORG_BANK_18
SECTION BANK_18_L
org CRT_ORG_BANK_18_L
SECTION BANK_18_H
org CRT_ORG_BANK_18_H
SECTION BANK_19
org CRT_ORG_BANK_19
SECTION BANK_19_L
org CRT_ORG_BANK_19_L
SECTION BANK_19_H
org CRT_ORG_BANK_19_H
SECTION BANK_20
org CRT_ORG_BANK_20
SECTION BANK_20_L
org CRT_ORG_BANK_20_L
SECTION BANK_20_H
org CRT_ORG_BANK_20_H
SECTION BANK_21
org CRT_ORG_BANK_21
SECTION BANK_21_L
org CRT_ORG_BANK_21_L
SECTION BANK_21_H
org CRT_ORG_BANK_21_H
SECTION BANK_22
org CRT_ORG_BANK_22
SECTION BANK_22_L
org CRT_ORG_BANK_22_L
SECTION BANK_22_H
org CRT_ORG_BANK_22_H
SECTION BANK_23
org CRT_ORG_BANK_23
SECTION BANK_23_L
org CRT_ORG_BANK_23_L
SECTION BANK_23_H
org CRT_ORG_BANK_23_H
SECTION BANK_24
org CRT_ORG_BANK_24
SECTION BANK_24_L
org CRT_ORG_BANK_24_L
SECTION BANK_24_H
org CRT_ORG_BANK_24_H
SECTION BANK_25
org CRT_ORG_BANK_25
SECTION BANK_25_L
org CRT_ORG_BANK_25_L
SECTION BANK_25_H
org CRT_ORG_BANK_25_H
SECTION BANK_26
org CRT_ORG_BANK_26
SECTION BANK_26_L
org CRT_ORG_BANK_26_L
SECTION BANK_26_H
org CRT_ORG_BANK_26_H
SECTION BANK_27
org CRT_ORG_BANK_27
SECTION BANK_27_L
org CRT_ORG_BANK_27_L
SECTION BANK_27_H
org CRT_ORG_BANK_27_H
SECTION BANK_28
org CRT_ORG_BANK_28
SECTION BANK_28_L
org CRT_ORG_BANK_28_L
SECTION BANK_28_H
org CRT_ORG_BANK_28_H
SECTION BANK_29
org CRT_ORG_BANK_29
SECTION BANK_29_L
org CRT_ORG_BANK_29_L
SECTION BANK_29_H
org CRT_ORG_BANK_29_H
SECTION BANK_30
org CRT_ORG_BANK_30
SECTION BANK_30_L
org CRT_ORG_BANK_30_L
SECTION BANK_30_H
org CRT_ORG_BANK_30_H
SECTION BANK_31
org CRT_ORG_BANK_31
SECTION BANK_31_L
org CRT_ORG_BANK_31_L
SECTION BANK_31_H
org CRT_ORG_BANK_31_H
SECTION BANK_32
org CRT_ORG_BANK_32
SECTION BANK_32_L
org CRT_ORG_BANK_32_L
SECTION BANK_32_H
org CRT_ORG_BANK_32_H
SECTION BANK_33
org CRT_ORG_BANK_33
SECTION BANK_33_L
org CRT_ORG_BANK_33_L
SECTION BANK_33_H
org CRT_ORG_BANK_33_H
SECTION BANK_34
org CRT_ORG_BANK_34
SECTION BANK_34_L
org CRT_ORG_BANK_34_L
SECTION BANK_34_H
org CRT_ORG_BANK_34_H
SECTION BANK_35
org CRT_ORG_BANK_35
SECTION BANK_35_L
org CRT_ORG_BANK_35_L
SECTION BANK_35_H
org CRT_ORG_BANK_35_H
SECTION BANK_36
org CRT_ORG_BANK_36
SECTION BANK_36_L
org CRT_ORG_BANK_36_L
SECTION BANK_36_H
org CRT_ORG_BANK_36_H
SECTION BANK_37
org CRT_ORG_BANK_37
SECTION BANK_37_L
org CRT_ORG_BANK_37_L
SECTION BANK_37_H
org CRT_ORG_BANK_37_H
SECTION BANK_38
org CRT_ORG_BANK_38
SECTION BANK_38_L
org CRT_ORG_BANK_38_L
SECTION BANK_38_H
org CRT_ORG_BANK_38_H
SECTION BANK_39
org CRT_ORG_BANK_39
SECTION BANK_39_L
org CRT_ORG_BANK_39_L
SECTION BANK_39_H
org CRT_ORG_BANK_39_H
SECTION BANK_40
org CRT_ORG_BANK_40
SECTION BANK_40_L
org CRT_ORG_BANK_40_L
SECTION BANK_40_H
org CRT_ORG_BANK_40_H
SECTION BANK_41
org CRT_ORG_BANK_41
SECTION BANK_41_L
org CRT_ORG_BANK_41_L
SECTION BANK_41_H
org CRT_ORG_BANK_41_H
SECTION BANK_42
org CRT_ORG_BANK_42
SECTION BANK_42_L
org CRT_ORG_BANK_42_L
SECTION BANK_42_H
org CRT_ORG_BANK_42_H
SECTION BANK_43
org CRT_ORG_BANK_43
SECTION BANK_43_L
org CRT_ORG_BANK_43_L
SECTION BANK_43_H
org CRT_ORG_BANK_43_H
SECTION BANK_44
org CRT_ORG_BANK_44
SECTION BANK_44_L
org CRT_ORG_BANK_44_L
SECTION BANK_44_H
org CRT_ORG_BANK_44_H
SECTION BANK_45
org CRT_ORG_BANK_45
SECTION BANK_45_L
org CRT_ORG_BANK_45_L
SECTION BANK_45_H
org CRT_ORG_BANK_45_H
SECTION BANK_46
org CRT_ORG_BANK_46
SECTION BANK_46_L
org CRT_ORG_BANK_46_L
SECTION BANK_46_H
org CRT_ORG_BANK_46_H
SECTION BANK_47
org CRT_ORG_BANK_47
SECTION BANK_47_L
org CRT_ORG_BANK_47_L
SECTION BANK_47_H
org CRT_ORG_BANK_47_H
SECTION BANK_48
org CRT_ORG_BANK_48
SECTION BANK_48_L
org CRT_ORG_BANK_48_L
SECTION BANK_48_H
org CRT_ORG_BANK_48_H
SECTION BANK_49
org CRT_ORG_BANK_49
SECTION BANK_49_L
org CRT_ORG_BANK_49_L
SECTION BANK_49_H
org CRT_ORG_BANK_49_H
SECTION BANK_50
org CRT_ORG_BANK_50
SECTION BANK_50_L
org CRT_ORG_BANK_50_L
SECTION BANK_50_H
org CRT_ORG_BANK_50_H
SECTION BANK_51
org CRT_ORG_BANK_51
SECTION BANK_51_L
org CRT_ORG_BANK_51_L
SECTION BANK_51_H
org CRT_ORG_BANK_51_H
SECTION BANK_52
org CRT_ORG_BANK_52
SECTION BANK_52_L
org CRT_ORG_BANK_52_L
SECTION BANK_52_H
org CRT_ORG_BANK_52_H
SECTION BANK_53
org CRT_ORG_BANK_53
SECTION BANK_53_L
org CRT_ORG_BANK_53_L
SECTION BANK_53_H
org CRT_ORG_BANK_53_H
SECTION BANK_54
org CRT_ORG_BANK_54
SECTION BANK_54_L
org CRT_ORG_BANK_54_L
SECTION BANK_54_H
org CRT_ORG_BANK_54_H
SECTION BANK_55
org CRT_ORG_BANK_55
SECTION BANK_55_L
org CRT_ORG_BANK_55_L
SECTION BANK_55_H
org CRT_ORG_BANK_55_H
SECTION BANK_56
org CRT_ORG_BANK_56
SECTION BANK_56_L
org CRT_ORG_BANK_56_L
SECTION BANK_56_H
org CRT_ORG_BANK_56_H
SECTION BANK_57
org CRT_ORG_BANK_57
SECTION BANK_57_L
org CRT_ORG_BANK_57_L
SECTION BANK_57_H
org CRT_ORG_BANK_57_H
SECTION BANK_58
org CRT_ORG_BANK_58
SECTION BANK_58_L
org CRT_ORG_BANK_58_L
SECTION BANK_58_H
org CRT_ORG_BANK_58_H
SECTION BANK_59
org CRT_ORG_BANK_59
SECTION BANK_59_L
org CRT_ORG_BANK_59_L
SECTION BANK_59_H
org CRT_ORG_BANK_59_H
SECTION BANK_60
org CRT_ORG_BANK_60
SECTION BANK_60_L
org CRT_ORG_BANK_60_L
SECTION BANK_60_H
org CRT_ORG_BANK_60_H
SECTION BANK_61
org CRT_ORG_BANK_61
SECTION BANK_61_L
org CRT_ORG_BANK_61_L
SECTION BANK_61_H
org CRT_ORG_BANK_61_H
SECTION BANK_62
org CRT_ORG_BANK_62
SECTION BANK_62_L
org CRT_ORG_BANK_62_L
SECTION BANK_62_H
org CRT_ORG_BANK_62_H
SECTION BANK_63
org CRT_ORG_BANK_63
SECTION BANK_63_L
org CRT_ORG_BANK_63_L
SECTION BANK_63_H
org CRT_ORG_BANK_63_H
SECTION BANK_64
org CRT_ORG_BANK_64
SECTION BANK_64_L
org CRT_ORG_BANK_64_L
SECTION BANK_64_H
org CRT_ORG_BANK_64_H
SECTION BANK_65
org CRT_ORG_BANK_65
SECTION BANK_65_L
org CRT_ORG_BANK_65_L
SECTION BANK_65_H
org CRT_ORG_BANK_65_H
SECTION BANK_66
org CRT_ORG_BANK_66
SECTION BANK_66_L
org CRT_ORG_BANK_66_L
SECTION BANK_66_H
org CRT_ORG_BANK_66_H
SECTION BANK_67
org CRT_ORG_BANK_67
SECTION BANK_67_L
org CRT_ORG_BANK_67_L
SECTION BANK_67_H
org CRT_ORG_BANK_67_H
SECTION BANK_68
org CRT_ORG_BANK_68
SECTION BANK_68_L
org CRT_ORG_BANK_68_L
SECTION BANK_68_H
org CRT_ORG_BANK_68_H
SECTION BANK_69
org CRT_ORG_BANK_69
SECTION BANK_69_L
org CRT_ORG_BANK_69_L
SECTION BANK_69_H
org CRT_ORG_BANK_69_H
SECTION BANK_70
org CRT_ORG_BANK_70
SECTION BANK_70_L
org CRT_ORG_BANK_70_L
SECTION BANK_70_H
org CRT_ORG_BANK_70_H
SECTION BANK_71
org CRT_ORG_BANK_71
SECTION BANK_71_L
org CRT_ORG_BANK_71_L
SECTION BANK_71_H
org CRT_ORG_BANK_71_H
SECTION BANK_72
org CRT_ORG_BANK_72
SECTION BANK_72_L
org CRT_ORG_BANK_72_L
SECTION BANK_72_H
org CRT_ORG_BANK_72_H
SECTION BANK_73
org CRT_ORG_BANK_73
SECTION BANK_73_L
org CRT_ORG_BANK_73_L
SECTION BANK_73_H
org CRT_ORG_BANK_73_H
SECTION BANK_74
org CRT_ORG_BANK_74
SECTION BANK_74_L
org CRT_ORG_BANK_74_L
SECTION BANK_74_H
org CRT_ORG_BANK_74_H
SECTION BANK_75
org CRT_ORG_BANK_75
SECTION BANK_75_L
org CRT_ORG_BANK_75_L
SECTION BANK_75_H
org CRT_ORG_BANK_75_H
SECTION BANK_76
org CRT_ORG_BANK_76
SECTION BANK_76_L
org CRT_ORG_BANK_76_L
SECTION BANK_76_H
org CRT_ORG_BANK_76_H
SECTION BANK_77
org CRT_ORG_BANK_77
SECTION BANK_77_L
org CRT_ORG_BANK_77_L
SECTION BANK_77_H
org CRT_ORG_BANK_77_H
SECTION BANK_78
org CRT_ORG_BANK_78
SECTION BANK_78_L
org CRT_ORG_BANK_78_L
SECTION BANK_78_H
org CRT_ORG_BANK_78_H
SECTION BANK_79
org CRT_ORG_BANK_79
SECTION BANK_79_L
org CRT_ORG_BANK_79_L
SECTION BANK_79_H
org CRT_ORG_BANK_79_H
SECTION BANK_80
org CRT_ORG_BANK_80
SECTION BANK_80_L
org CRT_ORG_BANK_80_L
SECTION BANK_80_H
org CRT_ORG_BANK_80_H
SECTION BANK_81
org CRT_ORG_BANK_81
SECTION BANK_81_L
org CRT_ORG_BANK_81_L
SECTION BANK_81_H
org CRT_ORG_BANK_81_H
SECTION BANK_82
org CRT_ORG_BANK_82
SECTION BANK_82_L
org CRT_ORG_BANK_82_L
SECTION BANK_82_H
org CRT_ORG_BANK_82_H
SECTION BANK_83
org CRT_ORG_BANK_83
SECTION BANK_83_L
org CRT_ORG_BANK_83_L
SECTION BANK_83_H
org CRT_ORG_BANK_83_H
SECTION BANK_84
org CRT_ORG_BANK_84
SECTION BANK_84_L
org CRT_ORG_BANK_84_L
SECTION BANK_84_H
org CRT_ORG_BANK_84_H
SECTION BANK_85
org CRT_ORG_BANK_85
SECTION BANK_85_L
org CRT_ORG_BANK_85_L
SECTION BANK_85_H
org CRT_ORG_BANK_85_H
SECTION BANK_86
org CRT_ORG_BANK_86
SECTION BANK_86_L
org CRT_ORG_BANK_86_L
SECTION BANK_86_H
org CRT_ORG_BANK_86_H
SECTION BANK_87
org CRT_ORG_BANK_87
SECTION BANK_87_L
org CRT_ORG_BANK_87_L
SECTION BANK_87_H
org CRT_ORG_BANK_87_H
SECTION BANK_88
org CRT_ORG_BANK_88
SECTION BANK_88_L
org CRT_ORG_BANK_88_L
SECTION BANK_88_H
org CRT_ORG_BANK_88_H
SECTION BANK_89
org CRT_ORG_BANK_89
SECTION BANK_89_L
org CRT_ORG_BANK_89_L
SECTION BANK_89_H
org CRT_ORG_BANK_89_H
SECTION BANK_90
org CRT_ORG_BANK_90
SECTION BANK_90_L
org CRT_ORG_BANK_90_L
SECTION BANK_90_H
org CRT_ORG_BANK_90_H
SECTION BANK_91
org CRT_ORG_BANK_91
SECTION BANK_91_L
org CRT_ORG_BANK_91_L
SECTION BANK_91_H
org CRT_ORG_BANK_91_H
SECTION BANK_92
org CRT_ORG_BANK_92
SECTION BANK_92_L
org CRT_ORG_BANK_92_L
SECTION BANK_92_H
org CRT_ORG_BANK_92_H
SECTION BANK_93
org CRT_ORG_BANK_93
SECTION BANK_93_L
org CRT_ORG_BANK_93_L
SECTION BANK_93_H
org CRT_ORG_BANK_93_H
SECTION BANK_94
org CRT_ORG_BANK_94
SECTION BANK_94_L
org CRT_ORG_BANK_94_L
SECTION BANK_94_H
org CRT_ORG_BANK_94_H
SECTION BANK_95
org CRT_ORG_BANK_95
SECTION BANK_95_L
org CRT_ORG_BANK_95_L
SECTION BANK_95_H
org CRT_ORG_BANK_95_H
SECTION BANK_96
org CRT_ORG_BANK_96
SECTION BANK_96_L
org CRT_ORG_BANK_96_L
SECTION BANK_96_H
org CRT_ORG_BANK_96_H
SECTION BANK_97
org CRT_ORG_BANK_97
SECTION BANK_97_L
org CRT_ORG_BANK_97_L
SECTION BANK_97_H
org CRT_ORG_BANK_97_H
SECTION BANK_98
org CRT_ORG_BANK_98
SECTION BANK_98_L
org CRT_ORG_BANK_98_L
SECTION BANK_98_H
org CRT_ORG_BANK_98_H
SECTION BANK_99
org CRT_ORG_BANK_99
SECTION BANK_99_L
org CRT_ORG_BANK_99_L
SECTION BANK_99_H
org CRT_ORG_BANK_99_H
SECTION BANK_100
org CRT_ORG_BANK_100
SECTION BANK_100_L
org CRT_ORG_BANK_100_L
SECTION BANK_100_H
org CRT_ORG_BANK_100_H
SECTION BANK_101
org CRT_ORG_BANK_101
SECTION BANK_101_L
org CRT_ORG_BANK_101_L
SECTION BANK_101_H
org CRT_ORG_BANK_101_H
SECTION BANK_102
org CRT_ORG_BANK_102
SECTION BANK_102_L
org CRT_ORG_BANK_102_L
SECTION BANK_102_H
org CRT_ORG_BANK_102_H
SECTION BANK_103
org CRT_ORG_BANK_103
SECTION BANK_103_L
org CRT_ORG_BANK_103_L
SECTION BANK_103_H
org CRT_ORG_BANK_103_H
SECTION BANK_104
org CRT_ORG_BANK_104
SECTION BANK_104_L
org CRT_ORG_BANK_104_L
SECTION BANK_104_H
org CRT_ORG_BANK_104_H
SECTION BANK_105
org CRT_ORG_BANK_105
SECTION BANK_105_L
org CRT_ORG_BANK_105_L
SECTION BANK_105_H
org CRT_ORG_BANK_105_H
SECTION BANK_106
org CRT_ORG_BANK_106
SECTION BANK_106_L
org CRT_ORG_BANK_106_L
SECTION BANK_106_H
org CRT_ORG_BANK_106_H
SECTION BANK_107
org CRT_ORG_BANK_107
SECTION BANK_107_L
org CRT_ORG_BANK_107_L
SECTION BANK_107_H
org CRT_ORG_BANK_107_H
SECTION BANK_108
org CRT_ORG_BANK_108
SECTION BANK_108_L
org CRT_ORG_BANK_108_L
SECTION BANK_108_H
org CRT_ORG_BANK_108_H
SECTION BANK_109
org CRT_ORG_BANK_109
SECTION BANK_109_L
org CRT_ORG_BANK_109_L
SECTION BANK_109_H
org CRT_ORG_BANK_109_H
SECTION BANK_110
org CRT_ORG_BANK_110
SECTION BANK_110_L
org CRT_ORG_BANK_110_L
SECTION BANK_110_H
org CRT_ORG_BANK_110_H
SECTION BANK_111
org CRT_ORG_BANK_111
SECTION BANK_111_L
org CRT_ORG_BANK_111_L
SECTION BANK_111_H
org CRT_ORG_BANK_111_H
SECTION PAGE_0
org CRT_ORG_PAGE_0
SECTION PAGE_1
org CRT_ORG_PAGE_1
SECTION PAGE_2
org CRT_ORG_PAGE_2
SECTION PAGE_3
org CRT_ORG_PAGE_3
SECTION PAGE_4
org CRT_ORG_PAGE_4
SECTION PAGE_5
org CRT_ORG_PAGE_5
SECTION PAGE_6
org CRT_ORG_PAGE_6
SECTION PAGE_7
org CRT_ORG_PAGE_7
SECTION PAGE_8
org CRT_ORG_PAGE_8
SECTION PAGE_9
org CRT_ORG_PAGE_9
SECTION PAGE_10
org CRT_ORG_PAGE_10
SECTION PAGE_11
org CRT_ORG_PAGE_11
SECTION PAGE_12
org CRT_ORG_PAGE_12
SECTION PAGE_13
org CRT_ORG_PAGE_13
SECTION PAGE_14
org CRT_ORG_PAGE_14
SECTION PAGE_15
org CRT_ORG_PAGE_15
SECTION PAGE_16
org CRT_ORG_PAGE_16
SECTION PAGE_17
org CRT_ORG_PAGE_17
SECTION PAGE_18
org CRT_ORG_PAGE_18
SECTION PAGE_19
org CRT_ORG_PAGE_19
SECTION PAGE_20
org CRT_ORG_PAGE_20
SECTION PAGE_21
org CRT_ORG_PAGE_21
SECTION PAGE_22
org CRT_ORG_PAGE_22
SECTION PAGE_23
org CRT_ORG_PAGE_23
SECTION PAGE_24
org CRT_ORG_PAGE_24
SECTION PAGE_25
org CRT_ORG_PAGE_25
SECTION PAGE_26
org CRT_ORG_PAGE_26
SECTION PAGE_27
org CRT_ORG_PAGE_27
SECTION PAGE_28
org CRT_ORG_PAGE_28
SECTION PAGE_29
org CRT_ORG_PAGE_29
SECTION PAGE_30
org CRT_ORG_PAGE_30
SECTION PAGE_31
org CRT_ORG_PAGE_31
SECTION PAGE_32
org CRT_ORG_PAGE_32
SECTION PAGE_33
org CRT_ORG_PAGE_33
SECTION PAGE_34
org CRT_ORG_PAGE_34
SECTION PAGE_35
org CRT_ORG_PAGE_35
SECTION PAGE_36
org CRT_ORG_PAGE_36
SECTION PAGE_37
org CRT_ORG_PAGE_37
SECTION PAGE_38
org CRT_ORG_PAGE_38
SECTION PAGE_39
org CRT_ORG_PAGE_39
SECTION PAGE_40
org CRT_ORG_PAGE_40
SECTION PAGE_41
org CRT_ORG_PAGE_41
SECTION PAGE_42
org CRT_ORG_PAGE_42
SECTION PAGE_43
org CRT_ORG_PAGE_43
SECTION PAGE_44
org CRT_ORG_PAGE_44
SECTION PAGE_45
org CRT_ORG_PAGE_45
SECTION PAGE_46
org CRT_ORG_PAGE_46
SECTION PAGE_47
org CRT_ORG_PAGE_47
SECTION PAGE_48
org CRT_ORG_PAGE_48
SECTION PAGE_49
org CRT_ORG_PAGE_49
SECTION PAGE_50
org CRT_ORG_PAGE_50
SECTION PAGE_51
org CRT_ORG_PAGE_51
SECTION PAGE_52
org CRT_ORG_PAGE_52
SECTION PAGE_53
org CRT_ORG_PAGE_53
SECTION PAGE_54
org CRT_ORG_PAGE_54
SECTION PAGE_55
org CRT_ORG_PAGE_55
SECTION PAGE_56
org CRT_ORG_PAGE_56
SECTION PAGE_57
org CRT_ORG_PAGE_57
SECTION PAGE_58
org CRT_ORG_PAGE_58
SECTION PAGE_59
org CRT_ORG_PAGE_59
SECTION PAGE_60
org CRT_ORG_PAGE_60
SECTION PAGE_61
org CRT_ORG_PAGE_61
SECTION PAGE_62
org CRT_ORG_PAGE_62
SECTION PAGE_63
org CRT_ORG_PAGE_63
SECTION PAGE_64
org CRT_ORG_PAGE_64
SECTION PAGE_65
org CRT_ORG_PAGE_65
SECTION PAGE_66
org CRT_ORG_PAGE_66
SECTION PAGE_67
org CRT_ORG_PAGE_67
SECTION PAGE_68
org CRT_ORG_PAGE_68
SECTION PAGE_69
org CRT_ORG_PAGE_69
SECTION PAGE_70
org CRT_ORG_PAGE_70
SECTION PAGE_71
org CRT_ORG_PAGE_71
SECTION PAGE_72
org CRT_ORG_PAGE_72
SECTION PAGE_73
org CRT_ORG_PAGE_73
SECTION PAGE_74
org CRT_ORG_PAGE_74
SECTION PAGE_75
org CRT_ORG_PAGE_75
SECTION PAGE_76
org CRT_ORG_PAGE_76
SECTION PAGE_77
org CRT_ORG_PAGE_77
SECTION PAGE_78
org CRT_ORG_PAGE_78
SECTION PAGE_79
org CRT_ORG_PAGE_79
SECTION PAGE_80
org CRT_ORG_PAGE_80
SECTION PAGE_81
org CRT_ORG_PAGE_81
SECTION PAGE_82
org CRT_ORG_PAGE_82
SECTION PAGE_83
org CRT_ORG_PAGE_83
SECTION PAGE_84
org CRT_ORG_PAGE_84
SECTION PAGE_85
org CRT_ORG_PAGE_85
SECTION PAGE_86
org CRT_ORG_PAGE_86
SECTION PAGE_87
org CRT_ORG_PAGE_87
SECTION PAGE_88
org CRT_ORG_PAGE_88
SECTION PAGE_89
org CRT_ORG_PAGE_89
SECTION PAGE_90
org CRT_ORG_PAGE_90
SECTION PAGE_91
org CRT_ORG_PAGE_91
SECTION PAGE_92
org CRT_ORG_PAGE_92
SECTION PAGE_93
org CRT_ORG_PAGE_93
SECTION PAGE_94
org CRT_ORG_PAGE_94
SECTION PAGE_95
org CRT_ORG_PAGE_95
SECTION PAGE_96
org CRT_ORG_PAGE_96
SECTION PAGE_97
org CRT_ORG_PAGE_97
SECTION PAGE_98
org CRT_ORG_PAGE_98
SECTION PAGE_99
org CRT_ORG_PAGE_99
SECTION PAGE_100
org CRT_ORG_PAGE_100
SECTION PAGE_101
org CRT_ORG_PAGE_101
SECTION PAGE_102
org CRT_ORG_PAGE_102
SECTION PAGE_103
org CRT_ORG_PAGE_103
SECTION PAGE_104
org CRT_ORG_PAGE_104
SECTION PAGE_105
org CRT_ORG_PAGE_105
SECTION PAGE_106
org CRT_ORG_PAGE_106
SECTION PAGE_107
org CRT_ORG_PAGE_107
SECTION PAGE_108
org CRT_ORG_PAGE_108
SECTION PAGE_109
org CRT_ORG_PAGE_109
SECTION PAGE_110
org CRT_ORG_PAGE_110
SECTION PAGE_111
org CRT_ORG_PAGE_111
SECTION PAGE_112
org CRT_ORG_PAGE_112
SECTION PAGE_113
org CRT_ORG_PAGE_113
SECTION PAGE_114
org CRT_ORG_PAGE_114
SECTION PAGE_115
org CRT_ORG_PAGE_115
SECTION PAGE_116
org CRT_ORG_PAGE_116
SECTION PAGE_117
org CRT_ORG_PAGE_117
SECTION PAGE_118
org CRT_ORG_PAGE_118
SECTION PAGE_119
org CRT_ORG_PAGE_119
SECTION PAGE_120
org CRT_ORG_PAGE_120
SECTION PAGE_121
org CRT_ORG_PAGE_121
SECTION PAGE_122
org CRT_ORG_PAGE_122
SECTION PAGE_123
org CRT_ORG_PAGE_123
SECTION PAGE_124
org CRT_ORG_PAGE_124
SECTION PAGE_125
org CRT_ORG_PAGE_125
SECTION PAGE_126
org CRT_ORG_PAGE_126
SECTION PAGE_127
org CRT_ORG_PAGE_127
SECTION PAGE_128
org CRT_ORG_PAGE_128
SECTION PAGE_129
org CRT_ORG_PAGE_129
SECTION PAGE_130
org CRT_ORG_PAGE_130
SECTION PAGE_131
org CRT_ORG_PAGE_131
SECTION PAGE_132
org CRT_ORG_PAGE_132
SECTION PAGE_133
org CRT_ORG_PAGE_133
SECTION PAGE_134
org CRT_ORG_PAGE_134
SECTION PAGE_135
org CRT_ORG_PAGE_135
SECTION PAGE_136
org CRT_ORG_PAGE_136
SECTION PAGE_137
org CRT_ORG_PAGE_137
SECTION PAGE_138
org CRT_ORG_PAGE_138
SECTION PAGE_139
org CRT_ORG_PAGE_139
SECTION PAGE_140
org CRT_ORG_PAGE_140
SECTION PAGE_141
org CRT_ORG_PAGE_141
SECTION PAGE_142
org CRT_ORG_PAGE_142
SECTION PAGE_143
org CRT_ORG_PAGE_143
SECTION PAGE_144
org CRT_ORG_PAGE_144
SECTION PAGE_145
org CRT_ORG_PAGE_145
SECTION PAGE_146
org CRT_ORG_PAGE_146
SECTION PAGE_147
org CRT_ORG_PAGE_147
SECTION PAGE_148
org CRT_ORG_PAGE_148
SECTION PAGE_149
org CRT_ORG_PAGE_149
SECTION PAGE_150
org CRT_ORG_PAGE_150
SECTION PAGE_151
org CRT_ORG_PAGE_151
SECTION PAGE_152
org CRT_ORG_PAGE_152
SECTION PAGE_153
org CRT_ORG_PAGE_153
SECTION PAGE_154
org CRT_ORG_PAGE_154
SECTION PAGE_155
org CRT_ORG_PAGE_155
SECTION PAGE_156
org CRT_ORG_PAGE_156
SECTION PAGE_157
org CRT_ORG_PAGE_157
SECTION PAGE_158
org CRT_ORG_PAGE_158
SECTION PAGE_159
org CRT_ORG_PAGE_159
SECTION PAGE_160
org CRT_ORG_PAGE_160
SECTION PAGE_161
org CRT_ORG_PAGE_161
SECTION PAGE_162
org CRT_ORG_PAGE_162
SECTION PAGE_163
org CRT_ORG_PAGE_163
SECTION PAGE_164
org CRT_ORG_PAGE_164
SECTION PAGE_165
org CRT_ORG_PAGE_165
SECTION PAGE_166
org CRT_ORG_PAGE_166
SECTION PAGE_167
org CRT_ORG_PAGE_167
SECTION PAGE_168
org CRT_ORG_PAGE_168
SECTION PAGE_169
org CRT_ORG_PAGE_169
SECTION PAGE_170
org CRT_ORG_PAGE_170
SECTION PAGE_171
org CRT_ORG_PAGE_171
SECTION PAGE_172
org CRT_ORG_PAGE_172
SECTION PAGE_173
org CRT_ORG_PAGE_173
SECTION PAGE_174
org CRT_ORG_PAGE_174
SECTION PAGE_175
org CRT_ORG_PAGE_175
SECTION PAGE_176
org CRT_ORG_PAGE_176
SECTION PAGE_177
org CRT_ORG_PAGE_177
SECTION PAGE_178
org CRT_ORG_PAGE_178
SECTION PAGE_179
org CRT_ORG_PAGE_179
SECTION PAGE_180
org CRT_ORG_PAGE_180
SECTION PAGE_181
org CRT_ORG_PAGE_181
SECTION PAGE_182
org CRT_ORG_PAGE_182
SECTION PAGE_183
org CRT_ORG_PAGE_183
SECTION PAGE_184
org CRT_ORG_PAGE_184
SECTION PAGE_185
org CRT_ORG_PAGE_185
SECTION PAGE_186
org CRT_ORG_PAGE_186
SECTION PAGE_187
org CRT_ORG_PAGE_187
SECTION PAGE_188
org CRT_ORG_PAGE_188
SECTION PAGE_189
org CRT_ORG_PAGE_189
SECTION PAGE_190
org CRT_ORG_PAGE_190
SECTION PAGE_191
org CRT_ORG_PAGE_191
SECTION PAGE_192
org CRT_ORG_PAGE_192
SECTION PAGE_193
org CRT_ORG_PAGE_193
SECTION PAGE_194
org CRT_ORG_PAGE_194
SECTION PAGE_195
org CRT_ORG_PAGE_195
SECTION PAGE_196
org CRT_ORG_PAGE_196
SECTION PAGE_197
org CRT_ORG_PAGE_197
SECTION PAGE_198
org CRT_ORG_PAGE_198
SECTION PAGE_199
org CRT_ORG_PAGE_199
SECTION PAGE_200
org CRT_ORG_PAGE_200
SECTION PAGE_201
org CRT_ORG_PAGE_201
SECTION PAGE_202
org CRT_ORG_PAGE_202
SECTION PAGE_203
org CRT_ORG_PAGE_203
SECTION PAGE_204
org CRT_ORG_PAGE_204
SECTION PAGE_205
org CRT_ORG_PAGE_205
SECTION PAGE_206
org CRT_ORG_PAGE_206
SECTION PAGE_207
org CRT_ORG_PAGE_207
SECTION PAGE_208
org CRT_ORG_PAGE_208
SECTION PAGE_209
org CRT_ORG_PAGE_209
SECTION PAGE_210
org CRT_ORG_PAGE_210
SECTION PAGE_211
org CRT_ORG_PAGE_211
SECTION PAGE_212
org CRT_ORG_PAGE_212
SECTION PAGE_213
org CRT_ORG_PAGE_213
SECTION PAGE_214
org CRT_ORG_PAGE_214
SECTION PAGE_215
org CRT_ORG_PAGE_215
SECTION PAGE_216
org CRT_ORG_PAGE_216
SECTION PAGE_217
org CRT_ORG_PAGE_217
SECTION PAGE_218
org CRT_ORG_PAGE_218
SECTION PAGE_219
org CRT_ORG_PAGE_219
SECTION PAGE_220
org CRT_ORG_PAGE_220
SECTION PAGE_221
org CRT_ORG_PAGE_221
SECTION PAGE_222
org CRT_ORG_PAGE_222
SECTION PAGE_223
org CRT_ORG_PAGE_223
SECTION DIV_0
org CRT_ORG_DIV_0
SECTION DIV_1
org CRT_ORG_DIV_1
SECTION DIV_2
org CRT_ORG_DIV_2
SECTION DIV_3
org CRT_ORG_DIV_3
SECTION DIV_4
org CRT_ORG_DIV_4
SECTION DIV_5
org CRT_ORG_DIV_5
SECTION DIV_6
org CRT_ORG_DIV_6
SECTION DIV_7
org CRT_ORG_DIV_7
SECTION DIV_8
org CRT_ORG_DIV_8
SECTION DIV_9
org CRT_ORG_DIV_9
SECTION DIV_10
org CRT_ORG_DIV_10
SECTION DIV_11
org CRT_ORG_DIV_11
SECTION DIV_12
org CRT_ORG_DIV_12
SECTION DIV_13
org CRT_ORG_DIV_13
SECTION DIV_14
org CRT_ORG_DIV_14
SECTION DIV_15
org CRT_ORG_DIV_15
SECTION UNASSIGNED
org 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ENDIF
IF __MMAP = 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; esxdos extended dot command ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
INCLUDE "crt_memory_model_dotx.inc"
SECTION BANK_0
org CRT_ORG_BANK_0
SECTION BANK_0_L
org CRT_ORG_BANK_0_L
SECTION BANK_0_H
org CRT_ORG_BANK_0_H
SECTION BANK_1
org CRT_ORG_BANK_1
SECTION BANK_1_L
org CRT_ORG_BANK_1_L
SECTION BANK_1_H
org CRT_ORG_BANK_1_H
SECTION BANK_2
org CRT_ORG_BANK_2
SECTION BANK_2_L
org CRT_ORG_BANK_2_L
SECTION BANK_2_H
org CRT_ORG_BANK_2_H
SECTION BANK_3
org CRT_ORG_BANK_3
SECTION BANK_3_L
org CRT_ORG_BANK_3_L
SECTION BANK_3_H
org CRT_ORG_BANK_3_H
SECTION BANK_4
org CRT_ORG_BANK_4
SECTION BANK_4_L
org CRT_ORG_BANK_4_L
SECTION BANK_4_H
org CRT_ORG_BANK_4_H
SECTION BANK_5
org CRT_ORG_BANK_5
SECTION BANK_5_L
org CRT_ORG_BANK_5_L
SECTION BANK_5_H
org CRT_ORG_BANK_5_H
SECTION BANK_6
org CRT_ORG_BANK_6
SECTION BANK_6_L
org CRT_ORG_BANK_6_L
SECTION BANK_6_H
org CRT_ORG_BANK_6_H
SECTION BANK_7
org CRT_ORG_BANK_7
SECTION BANK_7_L
org CRT_ORG_BANK_7_L
SECTION BANK_7_H
org CRT_ORG_BANK_7_H
SECTION BANK_8
org CRT_ORG_BANK_8
SECTION BANK_8_L
org CRT_ORG_BANK_8_L
SECTION BANK_8_H
org CRT_ORG_BANK_8_H
SECTION BANK_9
org CRT_ORG_BANK_9
SECTION BANK_9_L
org CRT_ORG_BANK_9_L
SECTION BANK_9_H
org CRT_ORG_BANK_9_H
SECTION BANK_10
org CRT_ORG_BANK_10
SECTION BANK_10_L
org CRT_ORG_BANK_10_L
SECTION BANK_10_H
org CRT_ORG_BANK_10_H
SECTION BANK_11
org CRT_ORG_BANK_11
SECTION BANK_11_L
org CRT_ORG_BANK_11_L
SECTION BANK_11_H
org CRT_ORG_BANK_11_H
SECTION BANK_12
org CRT_ORG_BANK_12
SECTION BANK_12_L
org CRT_ORG_BANK_12_L
SECTION BANK_12_H
org CRT_ORG_BANK_12_H
SECTION BANK_13
org CRT_ORG_BANK_13
SECTION BANK_13_L
org CRT_ORG_BANK_13_L
SECTION BANK_13_H
org CRT_ORG_BANK_13_H
SECTION BANK_14
org CRT_ORG_BANK_14
SECTION BANK_14_L
org CRT_ORG_BANK_14_L
SECTION BANK_14_H
org CRT_ORG_BANK_14_H
SECTION BANK_15
org CRT_ORG_BANK_15
SECTION BANK_15_L
org CRT_ORG_BANK_15_L
SECTION BANK_15_H
org CRT_ORG_BANK_15_H
SECTION BANK_16
org CRT_ORG_BANK_16
SECTION BANK_16_L
org CRT_ORG_BANK_16_L
SECTION BANK_16_H
org CRT_ORG_BANK_16_H
SECTION BANK_17
org CRT_ORG_BANK_17
SECTION BANK_17_L
org CRT_ORG_BANK_17_L
SECTION BANK_17_H
org CRT_ORG_BANK_17_H
SECTION BANK_18
org CRT_ORG_BANK_18
SECTION BANK_18_L
org CRT_ORG_BANK_18_L
SECTION BANK_18_H
org CRT_ORG_BANK_18_H
SECTION BANK_19
org CRT_ORG_BANK_19
SECTION BANK_19_L
org CRT_ORG_BANK_19_L
SECTION BANK_19_H
org CRT_ORG_BANK_19_H
SECTION BANK_20
org CRT_ORG_BANK_20
SECTION BANK_20_L
org CRT_ORG_BANK_20_L
SECTION BANK_20_H
org CRT_ORG_BANK_20_H
SECTION BANK_21
org CRT_ORG_BANK_21
SECTION BANK_21_L
org CRT_ORG_BANK_21_L
SECTION BANK_21_H
org CRT_ORG_BANK_21_H
SECTION BANK_22
org CRT_ORG_BANK_22
SECTION BANK_22_L
org CRT_ORG_BANK_22_L
SECTION BANK_22_H
org CRT_ORG_BANK_22_H
SECTION BANK_23
org CRT_ORG_BANK_23
SECTION BANK_23_L
org CRT_ORG_BANK_23_L
SECTION BANK_23_H
org CRT_ORG_BANK_23_H
SECTION BANK_24
org CRT_ORG_BANK_24
SECTION BANK_24_L
org CRT_ORG_BANK_24_L
SECTION BANK_24_H
org CRT_ORG_BANK_24_H
SECTION BANK_25
org CRT_ORG_BANK_25
SECTION BANK_25_L
org CRT_ORG_BANK_25_L
SECTION BANK_25_H
org CRT_ORG_BANK_25_H
SECTION BANK_26
org CRT_ORG_BANK_26
SECTION BANK_26_L
org CRT_ORG_BANK_26_L
SECTION BANK_26_H
org CRT_ORG_BANK_26_H
SECTION BANK_27
org CRT_ORG_BANK_27
SECTION BANK_27_L
org CRT_ORG_BANK_27_L
SECTION BANK_27_H
org CRT_ORG_BANK_27_H
SECTION BANK_28
org CRT_ORG_BANK_28
SECTION BANK_28_L
org CRT_ORG_BANK_28_L
SECTION BANK_28_H
org CRT_ORG_BANK_28_H
SECTION BANK_29
org CRT_ORG_BANK_29
SECTION BANK_29_L
org CRT_ORG_BANK_29_L
SECTION BANK_29_H
org CRT_ORG_BANK_29_H
SECTION BANK_30
org CRT_ORG_BANK_30
SECTION BANK_30_L
org CRT_ORG_BANK_30_L
SECTION BANK_30_H
org CRT_ORG_BANK_30_H
SECTION BANK_31
org CRT_ORG_BANK_31
SECTION BANK_31_L
org CRT_ORG_BANK_31_L
SECTION BANK_31_H
org CRT_ORG_BANK_31_H
SECTION BANK_32
org CRT_ORG_BANK_32
SECTION BANK_32_L
org CRT_ORG_BANK_32_L
SECTION BANK_32_H
org CRT_ORG_BANK_32_H
SECTION BANK_33
org CRT_ORG_BANK_33
SECTION BANK_33_L
org CRT_ORG_BANK_33_L
SECTION BANK_33_H
org CRT_ORG_BANK_33_H
SECTION BANK_34
org CRT_ORG_BANK_34
SECTION BANK_34_L
org CRT_ORG_BANK_34_L
SECTION BANK_34_H
org CRT_ORG_BANK_34_H
SECTION BANK_35
org CRT_ORG_BANK_35
SECTION BANK_35_L
org CRT_ORG_BANK_35_L
SECTION BANK_35_H
org CRT_ORG_BANK_35_H
SECTION BANK_36
org CRT_ORG_BANK_36
SECTION BANK_36_L
org CRT_ORG_BANK_36_L
SECTION BANK_36_H
org CRT_ORG_BANK_36_H
SECTION BANK_37
org CRT_ORG_BANK_37
SECTION BANK_37_L
org CRT_ORG_BANK_37_L
SECTION BANK_37_H
org CRT_ORG_BANK_37_H
SECTION BANK_38
org CRT_ORG_BANK_38
SECTION BANK_38_L
org CRT_ORG_BANK_38_L
SECTION BANK_38_H
org CRT_ORG_BANK_38_H
SECTION BANK_39
org CRT_ORG_BANK_39
SECTION BANK_39_L
org CRT_ORG_BANK_39_L
SECTION BANK_39_H
org CRT_ORG_BANK_39_H
SECTION BANK_40
org CRT_ORG_BANK_40
SECTION BANK_40_L
org CRT_ORG_BANK_40_L
SECTION BANK_40_H
org CRT_ORG_BANK_40_H
SECTION BANK_41
org CRT_ORG_BANK_41
SECTION BANK_41_L
org CRT_ORG_BANK_41_L
SECTION BANK_41_H
org CRT_ORG_BANK_41_H
SECTION BANK_42
org CRT_ORG_BANK_42
SECTION BANK_42_L
org CRT_ORG_BANK_42_L
SECTION BANK_42_H
org CRT_ORG_BANK_42_H
SECTION BANK_43
org CRT_ORG_BANK_43
SECTION BANK_43_L
org CRT_ORG_BANK_43_L
SECTION BANK_43_H
org CRT_ORG_BANK_43_H
SECTION BANK_44
org CRT_ORG_BANK_44
SECTION BANK_44_L
org CRT_ORG_BANK_44_L
SECTION BANK_44_H
org CRT_ORG_BANK_44_H
SECTION BANK_45
org CRT_ORG_BANK_45
SECTION BANK_45_L
org CRT_ORG_BANK_45_L
SECTION BANK_45_H
org CRT_ORG_BANK_45_H
SECTION BANK_46
org CRT_ORG_BANK_46
SECTION BANK_46_L
org CRT_ORG_BANK_46_L
SECTION BANK_46_H
org CRT_ORG_BANK_46_H
SECTION BANK_47
org CRT_ORG_BANK_47
SECTION BANK_47_L
org CRT_ORG_BANK_47_L
SECTION BANK_47_H
org CRT_ORG_BANK_47_H
SECTION BANK_48
org CRT_ORG_BANK_48
SECTION BANK_48_L
org CRT_ORG_BANK_48_L
SECTION BANK_48_H
org CRT_ORG_BANK_48_H
SECTION BANK_49
org CRT_ORG_BANK_49
SECTION BANK_49_L
org CRT_ORG_BANK_49_L
SECTION BANK_49_H
org CRT_ORG_BANK_49_H
SECTION BANK_50
org CRT_ORG_BANK_50
SECTION BANK_50_L
org CRT_ORG_BANK_50_L
SECTION BANK_50_H
org CRT_ORG_BANK_50_H
SECTION BANK_51
org CRT_ORG_BANK_51
SECTION BANK_51_L
org CRT_ORG_BANK_51_L
SECTION BANK_51_H
org CRT_ORG_BANK_51_H
SECTION BANK_52
org CRT_ORG_BANK_52
SECTION BANK_52_L
org CRT_ORG_BANK_52_L
SECTION BANK_52_H
org CRT_ORG_BANK_52_H
SECTION BANK_53
org CRT_ORG_BANK_53
SECTION BANK_53_L
org CRT_ORG_BANK_53_L
SECTION BANK_53_H
org CRT_ORG_BANK_53_H
SECTION BANK_54
org CRT_ORG_BANK_54
SECTION BANK_54_L
org CRT_ORG_BANK_54_L
SECTION BANK_54_H
org CRT_ORG_BANK_54_H
SECTION BANK_55
org CRT_ORG_BANK_55
SECTION BANK_55_L
org CRT_ORG_BANK_55_L
SECTION BANK_55_H
org CRT_ORG_BANK_55_H
SECTION BANK_56
org CRT_ORG_BANK_56
SECTION BANK_56_L
org CRT_ORG_BANK_56_L
SECTION BANK_56_H
org CRT_ORG_BANK_56_H
SECTION BANK_57
org CRT_ORG_BANK_57
SECTION BANK_57_L
org CRT_ORG_BANK_57_L
SECTION BANK_57_H
org CRT_ORG_BANK_57_H
SECTION BANK_58
org CRT_ORG_BANK_58
SECTION BANK_58_L
org CRT_ORG_BANK_58_L
SECTION BANK_58_H
org CRT_ORG_BANK_58_H
SECTION BANK_59
org CRT_ORG_BANK_59
SECTION BANK_59_L
org CRT_ORG_BANK_59_L
SECTION BANK_59_H
org CRT_ORG_BANK_59_H
SECTION BANK_60
org CRT_ORG_BANK_60
SECTION BANK_60_L
org CRT_ORG_BANK_60_L
SECTION BANK_60_H
org CRT_ORG_BANK_60_H
SECTION BANK_61
org CRT_ORG_BANK_61
SECTION BANK_61_L
org CRT_ORG_BANK_61_L
SECTION BANK_61_H
org CRT_ORG_BANK_61_H
SECTION BANK_62
org CRT_ORG_BANK_62
SECTION BANK_62_L
org CRT_ORG_BANK_62_L
SECTION BANK_62_H
org CRT_ORG_BANK_62_H
SECTION BANK_63
org CRT_ORG_BANK_63
SECTION BANK_63_L
org CRT_ORG_BANK_63_L
SECTION BANK_63_H
org CRT_ORG_BANK_63_H
SECTION BANK_64
org CRT_ORG_BANK_64
SECTION BANK_64_L
org CRT_ORG_BANK_64_L
SECTION BANK_64_H
org CRT_ORG_BANK_64_H
SECTION BANK_65
org CRT_ORG_BANK_65
SECTION BANK_65_L
org CRT_ORG_BANK_65_L
SECTION BANK_65_H
org CRT_ORG_BANK_65_H
SECTION BANK_66
org CRT_ORG_BANK_66
SECTION BANK_66_L
org CRT_ORG_BANK_66_L
SECTION BANK_66_H
org CRT_ORG_BANK_66_H
SECTION BANK_67
org CRT_ORG_BANK_67
SECTION BANK_67_L
org CRT_ORG_BANK_67_L
SECTION BANK_67_H
org CRT_ORG_BANK_67_H
SECTION BANK_68
org CRT_ORG_BANK_68
SECTION BANK_68_L
org CRT_ORG_BANK_68_L
SECTION BANK_68_H
org CRT_ORG_BANK_68_H
SECTION BANK_69
org CRT_ORG_BANK_69
SECTION BANK_69_L
org CRT_ORG_BANK_69_L
SECTION BANK_69_H
org CRT_ORG_BANK_69_H
SECTION BANK_70
org CRT_ORG_BANK_70
SECTION BANK_70_L
org CRT_ORG_BANK_70_L
SECTION BANK_70_H
org CRT_ORG_BANK_70_H
SECTION BANK_71
org CRT_ORG_BANK_71
SECTION BANK_71_L
org CRT_ORG_BANK_71_L
SECTION BANK_71_H
org CRT_ORG_BANK_71_H
SECTION BANK_72
org CRT_ORG_BANK_72
SECTION BANK_72_L
org CRT_ORG_BANK_72_L
SECTION BANK_72_H
org CRT_ORG_BANK_72_H
SECTION BANK_73
org CRT_ORG_BANK_73
SECTION BANK_73_L
org CRT_ORG_BANK_73_L
SECTION BANK_73_H
org CRT_ORG_BANK_73_H
SECTION BANK_74
org CRT_ORG_BANK_74
SECTION BANK_74_L
org CRT_ORG_BANK_74_L
SECTION BANK_74_H
org CRT_ORG_BANK_74_H
SECTION BANK_75
org CRT_ORG_BANK_75
SECTION BANK_75_L
org CRT_ORG_BANK_75_L
SECTION BANK_75_H
org CRT_ORG_BANK_75_H
SECTION BANK_76
org CRT_ORG_BANK_76
SECTION BANK_76_L
org CRT_ORG_BANK_76_L
SECTION BANK_76_H
org CRT_ORG_BANK_76_H
SECTION BANK_77
org CRT_ORG_BANK_77
SECTION BANK_77_L
org CRT_ORG_BANK_77_L
SECTION BANK_77_H
org CRT_ORG_BANK_77_H
SECTION BANK_78
org CRT_ORG_BANK_78
SECTION BANK_78_L
org CRT_ORG_BANK_78_L
SECTION BANK_78_H
org CRT_ORG_BANK_78_H
SECTION BANK_79
org CRT_ORG_BANK_79
SECTION BANK_79_L
org CRT_ORG_BANK_79_L
SECTION BANK_79_H
org CRT_ORG_BANK_79_H
SECTION BANK_80
org CRT_ORG_BANK_80
SECTION BANK_80_L
org CRT_ORG_BANK_80_L
SECTION BANK_80_H
org CRT_ORG_BANK_80_H
SECTION BANK_81
org CRT_ORG_BANK_81
SECTION BANK_81_L
org CRT_ORG_BANK_81_L
SECTION BANK_81_H
org CRT_ORG_BANK_81_H
SECTION BANK_82
org CRT_ORG_BANK_82
SECTION BANK_82_L
org CRT_ORG_BANK_82_L
SECTION BANK_82_H
org CRT_ORG_BANK_82_H
SECTION BANK_83
org CRT_ORG_BANK_83
SECTION BANK_83_L
org CRT_ORG_BANK_83_L
SECTION BANK_83_H
org CRT_ORG_BANK_83_H
SECTION BANK_84
org CRT_ORG_BANK_84
SECTION BANK_84_L
org CRT_ORG_BANK_84_L
SECTION BANK_84_H
org CRT_ORG_BANK_84_H
SECTION BANK_85
org CRT_ORG_BANK_85
SECTION BANK_85_L
org CRT_ORG_BANK_85_L
SECTION BANK_85_H
org CRT_ORG_BANK_85_H
SECTION BANK_86
org CRT_ORG_BANK_86
SECTION BANK_86_L
org CRT_ORG_BANK_86_L
SECTION BANK_86_H
org CRT_ORG_BANK_86_H
SECTION BANK_87
org CRT_ORG_BANK_87
SECTION BANK_87_L
org CRT_ORG_BANK_87_L
SECTION BANK_87_H
org CRT_ORG_BANK_87_H
SECTION BANK_88
org CRT_ORG_BANK_88
SECTION BANK_88_L
org CRT_ORG_BANK_88_L
SECTION BANK_88_H
org CRT_ORG_BANK_88_H
SECTION BANK_89
org CRT_ORG_BANK_89
SECTION BANK_89_L
org CRT_ORG_BANK_89_L
SECTION BANK_89_H
org CRT_ORG_BANK_89_H
SECTION BANK_90
org CRT_ORG_BANK_90
SECTION BANK_90_L
org CRT_ORG_BANK_90_L
SECTION BANK_90_H
org CRT_ORG_BANK_90_H
SECTION BANK_91
org CRT_ORG_BANK_91
SECTION BANK_91_L
org CRT_ORG_BANK_91_L
SECTION BANK_91_H
org CRT_ORG_BANK_91_H
SECTION BANK_92
org CRT_ORG_BANK_92
SECTION BANK_92_L
org CRT_ORG_BANK_92_L
SECTION BANK_92_H
org CRT_ORG_BANK_92_H
SECTION BANK_93
org CRT_ORG_BANK_93
SECTION BANK_93_L
org CRT_ORG_BANK_93_L
SECTION BANK_93_H
org CRT_ORG_BANK_93_H
SECTION BANK_94
org CRT_ORG_BANK_94
SECTION BANK_94_L
org CRT_ORG_BANK_94_L
SECTION BANK_94_H
org CRT_ORG_BANK_94_H
SECTION BANK_95
org CRT_ORG_BANK_95
SECTION BANK_95_L
org CRT_ORG_BANK_95_L
SECTION BANK_95_H
org CRT_ORG_BANK_95_H
SECTION BANK_96
org CRT_ORG_BANK_96
SECTION BANK_96_L
org CRT_ORG_BANK_96_L
SECTION BANK_96_H
org CRT_ORG_BANK_96_H
SECTION BANK_97
org CRT_ORG_BANK_97
SECTION BANK_97_L
org CRT_ORG_BANK_97_L
SECTION BANK_97_H
org CRT_ORG_BANK_97_H
SECTION BANK_98
org CRT_ORG_BANK_98
SECTION BANK_98_L
org CRT_ORG_BANK_98_L
SECTION BANK_98_H
org CRT_ORG_BANK_98_H
SECTION BANK_99
org CRT_ORG_BANK_99
SECTION BANK_99_L
org CRT_ORG_BANK_99_L
SECTION BANK_99_H
org CRT_ORG_BANK_99_H
SECTION BANK_100
org CRT_ORG_BANK_100
SECTION BANK_100_L
org CRT_ORG_BANK_100_L
SECTION BANK_100_H
org CRT_ORG_BANK_100_H
SECTION BANK_101
org CRT_ORG_BANK_101
SECTION BANK_101_L
org CRT_ORG_BANK_101_L
SECTION BANK_101_H
org CRT_ORG_BANK_101_H
SECTION BANK_102
org CRT_ORG_BANK_102
SECTION BANK_102_L
org CRT_ORG_BANK_102_L
SECTION BANK_102_H
org CRT_ORG_BANK_102_H
SECTION BANK_103
org CRT_ORG_BANK_103
SECTION BANK_103_L
org CRT_ORG_BANK_103_L
SECTION BANK_103_H
org CRT_ORG_BANK_103_H
SECTION BANK_104
org CRT_ORG_BANK_104
SECTION BANK_104_L
org CRT_ORG_BANK_104_L
SECTION BANK_104_H
org CRT_ORG_BANK_104_H
SECTION BANK_105
org CRT_ORG_BANK_105
SECTION BANK_105_L
org CRT_ORG_BANK_105_L
SECTION BANK_105_H
org CRT_ORG_BANK_105_H
SECTION BANK_106
org CRT_ORG_BANK_106
SECTION BANK_106_L
org CRT_ORG_BANK_106_L
SECTION BANK_106_H
org CRT_ORG_BANK_106_H
SECTION BANK_107
org CRT_ORG_BANK_107
SECTION BANK_107_L
org CRT_ORG_BANK_107_L
SECTION BANK_107_H
org CRT_ORG_BANK_107_H
SECTION BANK_108
org CRT_ORG_BANK_108
SECTION BANK_108_L
org CRT_ORG_BANK_108_L
SECTION BANK_108_H
org CRT_ORG_BANK_108_H
SECTION BANK_109
org CRT_ORG_BANK_109
SECTION BANK_109_L
org CRT_ORG_BANK_109_L
SECTION BANK_109_H
org CRT_ORG_BANK_109_H
SECTION BANK_110
org CRT_ORG_BANK_110
SECTION BANK_110_L
org CRT_ORG_BANK_110_L
SECTION BANK_110_H
org CRT_ORG_BANK_110_H
SECTION BANK_111
org CRT_ORG_BANK_111
SECTION BANK_111_L
org CRT_ORG_BANK_111_L
SECTION BANK_111_H
org CRT_ORG_BANK_111_H
SECTION PAGE_0
org CRT_ORG_PAGE_0
SECTION PAGE_1
org CRT_ORG_PAGE_1
SECTION PAGE_2
org CRT_ORG_PAGE_2
SECTION PAGE_3
org CRT_ORG_PAGE_3
SECTION PAGE_4
org CRT_ORG_PAGE_4
SECTION PAGE_5
org CRT_ORG_PAGE_5
SECTION PAGE_6
org CRT_ORG_PAGE_6
SECTION PAGE_7
org CRT_ORG_PAGE_7
SECTION PAGE_8
org CRT_ORG_PAGE_8
SECTION PAGE_9
org CRT_ORG_PAGE_9
SECTION PAGE_10
org CRT_ORG_PAGE_10
SECTION PAGE_11
org CRT_ORG_PAGE_11
SECTION PAGE_12
org CRT_ORG_PAGE_12
SECTION PAGE_13
org CRT_ORG_PAGE_13
SECTION PAGE_14
org CRT_ORG_PAGE_14
SECTION PAGE_15
org CRT_ORG_PAGE_15
SECTION PAGE_16
org CRT_ORG_PAGE_16
SECTION PAGE_17
org CRT_ORG_PAGE_17
SECTION PAGE_18
org CRT_ORG_PAGE_18
SECTION PAGE_19
org CRT_ORG_PAGE_19
SECTION PAGE_20
org CRT_ORG_PAGE_20
SECTION PAGE_21
org CRT_ORG_PAGE_21
SECTION PAGE_22
org CRT_ORG_PAGE_22
SECTION PAGE_23
org CRT_ORG_PAGE_23
SECTION PAGE_24
org CRT_ORG_PAGE_24
SECTION PAGE_25
org CRT_ORG_PAGE_25
SECTION PAGE_26
org CRT_ORG_PAGE_26
SECTION PAGE_27
org CRT_ORG_PAGE_27
SECTION PAGE_28
org CRT_ORG_PAGE_28
SECTION PAGE_29
org CRT_ORG_PAGE_29
SECTION PAGE_30
org CRT_ORG_PAGE_30
SECTION PAGE_31
org CRT_ORG_PAGE_31
SECTION PAGE_32
org CRT_ORG_PAGE_32
SECTION PAGE_33
org CRT_ORG_PAGE_33
SECTION PAGE_34
org CRT_ORG_PAGE_34
SECTION PAGE_35
org CRT_ORG_PAGE_35
SECTION PAGE_36
org CRT_ORG_PAGE_36
SECTION PAGE_37
org CRT_ORG_PAGE_37
SECTION PAGE_38
org CRT_ORG_PAGE_38
SECTION PAGE_39
org CRT_ORG_PAGE_39
SECTION PAGE_40
org CRT_ORG_PAGE_40
SECTION PAGE_41
org CRT_ORG_PAGE_41
SECTION PAGE_42
org CRT_ORG_PAGE_42
SECTION PAGE_43
org CRT_ORG_PAGE_43
SECTION PAGE_44
org CRT_ORG_PAGE_44
SECTION PAGE_45
org CRT_ORG_PAGE_45
SECTION PAGE_46
org CRT_ORG_PAGE_46
SECTION PAGE_47
org CRT_ORG_PAGE_47
SECTION PAGE_48
org CRT_ORG_PAGE_48
SECTION PAGE_49
org CRT_ORG_PAGE_49
SECTION PAGE_50
org CRT_ORG_PAGE_50
SECTION PAGE_51
org CRT_ORG_PAGE_51
SECTION PAGE_52
org CRT_ORG_PAGE_52
SECTION PAGE_53
org CRT_ORG_PAGE_53
SECTION PAGE_54
org CRT_ORG_PAGE_54
SECTION PAGE_55
org CRT_ORG_PAGE_55
SECTION PAGE_56
org CRT_ORG_PAGE_56
SECTION PAGE_57
org CRT_ORG_PAGE_57
SECTION PAGE_58
org CRT_ORG_PAGE_58
SECTION PAGE_59
org CRT_ORG_PAGE_59
SECTION PAGE_60
org CRT_ORG_PAGE_60
SECTION PAGE_61
org CRT_ORG_PAGE_61
SECTION PAGE_62
org CRT_ORG_PAGE_62
SECTION PAGE_63
org CRT_ORG_PAGE_63
SECTION PAGE_64
org CRT_ORG_PAGE_64
SECTION PAGE_65
org CRT_ORG_PAGE_65
SECTION PAGE_66
org CRT_ORG_PAGE_66
SECTION PAGE_67
org CRT_ORG_PAGE_67
SECTION PAGE_68
org CRT_ORG_PAGE_68
SECTION PAGE_69
org CRT_ORG_PAGE_69
SECTION PAGE_70
org CRT_ORG_PAGE_70
SECTION PAGE_71
org CRT_ORG_PAGE_71
SECTION PAGE_72
org CRT_ORG_PAGE_72
SECTION PAGE_73
org CRT_ORG_PAGE_73
SECTION PAGE_74
org CRT_ORG_PAGE_74
SECTION PAGE_75
org CRT_ORG_PAGE_75
SECTION PAGE_76
org CRT_ORG_PAGE_76
SECTION PAGE_77
org CRT_ORG_PAGE_77
SECTION PAGE_78
org CRT_ORG_PAGE_78
SECTION PAGE_79
org CRT_ORG_PAGE_79
SECTION PAGE_80
org CRT_ORG_PAGE_80
SECTION PAGE_81
org CRT_ORG_PAGE_81
SECTION PAGE_82
org CRT_ORG_PAGE_82
SECTION PAGE_83
org CRT_ORG_PAGE_83
SECTION PAGE_84
org CRT_ORG_PAGE_84
SECTION PAGE_85
org CRT_ORG_PAGE_85
SECTION PAGE_86
org CRT_ORG_PAGE_86
SECTION PAGE_87
org CRT_ORG_PAGE_87
SECTION PAGE_88
org CRT_ORG_PAGE_88
SECTION PAGE_89
org CRT_ORG_PAGE_89
SECTION PAGE_90
org CRT_ORG_PAGE_90
SECTION PAGE_91
org CRT_ORG_PAGE_91
SECTION PAGE_92
org CRT_ORG_PAGE_92
SECTION PAGE_93
org CRT_ORG_PAGE_93
SECTION PAGE_94
org CRT_ORG_PAGE_94
SECTION PAGE_95
org CRT_ORG_PAGE_95
SECTION PAGE_96
org CRT_ORG_PAGE_96
SECTION PAGE_97
org CRT_ORG_PAGE_97
SECTION PAGE_98
org CRT_ORG_PAGE_98
SECTION PAGE_99
org CRT_ORG_PAGE_99
SECTION PAGE_100
org CRT_ORG_PAGE_100
SECTION PAGE_101
org CRT_ORG_PAGE_101
SECTION PAGE_102
org CRT_ORG_PAGE_102
SECTION PAGE_103
org CRT_ORG_PAGE_103
SECTION PAGE_104
org CRT_ORG_PAGE_104
SECTION PAGE_105
org CRT_ORG_PAGE_105
SECTION PAGE_106
org CRT_ORG_PAGE_106
SECTION PAGE_107
org CRT_ORG_PAGE_107
SECTION PAGE_108
org CRT_ORG_PAGE_108
SECTION PAGE_109
org CRT_ORG_PAGE_109
SECTION PAGE_110
org CRT_ORG_PAGE_110
SECTION PAGE_111
org CRT_ORG_PAGE_111
SECTION PAGE_112
org CRT_ORG_PAGE_112
SECTION PAGE_113
org CRT_ORG_PAGE_113
SECTION PAGE_114
org CRT_ORG_PAGE_114
SECTION PAGE_115
org CRT_ORG_PAGE_115
SECTION PAGE_116
org CRT_ORG_PAGE_116
SECTION PAGE_117
org CRT_ORG_PAGE_117
SECTION PAGE_118
org CRT_ORG_PAGE_118
SECTION PAGE_119
org CRT_ORG_PAGE_119
SECTION PAGE_120
org CRT_ORG_PAGE_120
SECTION PAGE_121
org CRT_ORG_PAGE_121
SECTION PAGE_122
org CRT_ORG_PAGE_122
SECTION PAGE_123
org CRT_ORG_PAGE_123
SECTION PAGE_124
org CRT_ORG_PAGE_124
SECTION PAGE_125
org CRT_ORG_PAGE_125
SECTION PAGE_126
org CRT_ORG_PAGE_126
SECTION PAGE_127
org CRT_ORG_PAGE_127
SECTION PAGE_128
org CRT_ORG_PAGE_128
SECTION PAGE_129
org CRT_ORG_PAGE_129
SECTION PAGE_130
org CRT_ORG_PAGE_130
SECTION PAGE_131
org CRT_ORG_PAGE_131
SECTION PAGE_132
org CRT_ORG_PAGE_132
SECTION PAGE_133
org CRT_ORG_PAGE_133
SECTION PAGE_134
org CRT_ORG_PAGE_134
SECTION PAGE_135
org CRT_ORG_PAGE_135
SECTION PAGE_136
org CRT_ORG_PAGE_136
SECTION PAGE_137
org CRT_ORG_PAGE_137
SECTION PAGE_138
org CRT_ORG_PAGE_138
SECTION PAGE_139
org CRT_ORG_PAGE_139
SECTION PAGE_140
org CRT_ORG_PAGE_140
SECTION PAGE_141
org CRT_ORG_PAGE_141
SECTION PAGE_142
org CRT_ORG_PAGE_142
SECTION PAGE_143
org CRT_ORG_PAGE_143
SECTION PAGE_144
org CRT_ORG_PAGE_144
SECTION PAGE_145
org CRT_ORG_PAGE_145
SECTION PAGE_146
org CRT_ORG_PAGE_146
SECTION PAGE_147
org CRT_ORG_PAGE_147
SECTION PAGE_148
org CRT_ORG_PAGE_148
SECTION PAGE_149
org CRT_ORG_PAGE_149
SECTION PAGE_150
org CRT_ORG_PAGE_150
SECTION PAGE_151
org CRT_ORG_PAGE_151
SECTION PAGE_152
org CRT_ORG_PAGE_152
SECTION PAGE_153
org CRT_ORG_PAGE_153
SECTION PAGE_154
org CRT_ORG_PAGE_154
SECTION PAGE_155
org CRT_ORG_PAGE_155
SECTION PAGE_156
org CRT_ORG_PAGE_156
SECTION PAGE_157
org CRT_ORG_PAGE_157
SECTION PAGE_158
org CRT_ORG_PAGE_158
SECTION PAGE_159
org CRT_ORG_PAGE_159
SECTION PAGE_160
org CRT_ORG_PAGE_160
SECTION PAGE_161
org CRT_ORG_PAGE_161
SECTION PAGE_162
org CRT_ORG_PAGE_162
SECTION PAGE_163
org CRT_ORG_PAGE_163
SECTION PAGE_164
org CRT_ORG_PAGE_164
SECTION PAGE_165
org CRT_ORG_PAGE_165
SECTION PAGE_166
org CRT_ORG_PAGE_166
SECTION PAGE_167
org CRT_ORG_PAGE_167
SECTION PAGE_168
org CRT_ORG_PAGE_168
SECTION PAGE_169
org CRT_ORG_PAGE_169
SECTION PAGE_170
org CRT_ORG_PAGE_170
SECTION PAGE_171
org CRT_ORG_PAGE_171
SECTION PAGE_172
org CRT_ORG_PAGE_172
SECTION PAGE_173
org CRT_ORG_PAGE_173
SECTION PAGE_174
org CRT_ORG_PAGE_174
SECTION PAGE_175
org CRT_ORG_PAGE_175
SECTION PAGE_176
org CRT_ORG_PAGE_176
SECTION PAGE_177
org CRT_ORG_PAGE_177
SECTION PAGE_178
org CRT_ORG_PAGE_178
SECTION PAGE_179
org CRT_ORG_PAGE_179
SECTION PAGE_180
org CRT_ORG_PAGE_180
SECTION PAGE_181
org CRT_ORG_PAGE_181
SECTION PAGE_182
org CRT_ORG_PAGE_182
SECTION PAGE_183
org CRT_ORG_PAGE_183
SECTION PAGE_184
org CRT_ORG_PAGE_184
SECTION PAGE_185
org CRT_ORG_PAGE_185
SECTION PAGE_186
org CRT_ORG_PAGE_186
SECTION PAGE_187
org CRT_ORG_PAGE_187
SECTION PAGE_188
org CRT_ORG_PAGE_188
SECTION PAGE_189
org CRT_ORG_PAGE_189
SECTION PAGE_190
org CRT_ORG_PAGE_190
SECTION PAGE_191
org CRT_ORG_PAGE_191
SECTION PAGE_192
org CRT_ORG_PAGE_192
SECTION PAGE_193
org CRT_ORG_PAGE_193
SECTION PAGE_194
org CRT_ORG_PAGE_194
SECTION PAGE_195
org CRT_ORG_PAGE_195
SECTION PAGE_196
org CRT_ORG_PAGE_196
SECTION PAGE_197
org CRT_ORG_PAGE_197
SECTION PAGE_198
org CRT_ORG_PAGE_198
SECTION PAGE_199
org CRT_ORG_PAGE_199
SECTION PAGE_200
org CRT_ORG_PAGE_200
SECTION PAGE_201
org CRT_ORG_PAGE_201
SECTION PAGE_202
org CRT_ORG_PAGE_202
SECTION PAGE_203
org CRT_ORG_PAGE_203
SECTION PAGE_204
org CRT_ORG_PAGE_204
SECTION PAGE_205
org CRT_ORG_PAGE_205
SECTION PAGE_206
org CRT_ORG_PAGE_206
SECTION PAGE_207
org CRT_ORG_PAGE_207
SECTION PAGE_208
org CRT_ORG_PAGE_208
SECTION PAGE_209
org CRT_ORG_PAGE_209
SECTION PAGE_210
org CRT_ORG_PAGE_210
SECTION PAGE_211
org CRT_ORG_PAGE_211
SECTION PAGE_212
org CRT_ORG_PAGE_212
SECTION PAGE_213
org CRT_ORG_PAGE_213
SECTION PAGE_214
org CRT_ORG_PAGE_214
SECTION PAGE_215
org CRT_ORG_PAGE_215
SECTION PAGE_216
org CRT_ORG_PAGE_216
SECTION PAGE_217
org CRT_ORG_PAGE_217
SECTION PAGE_218
org CRT_ORG_PAGE_218
SECTION PAGE_219
org CRT_ORG_PAGE_219
SECTION PAGE_220
org CRT_ORG_PAGE_220
SECTION PAGE_221
org CRT_ORG_PAGE_221
SECTION PAGE_222
org CRT_ORG_PAGE_222
SECTION PAGE_223
org CRT_ORG_PAGE_223
SECTION DIV_0
org CRT_ORG_DIV_0
SECTION DIV_1
org CRT_ORG_DIV_1
SECTION DIV_2
org CRT_ORG_DIV_2
SECTION DIV_3
org CRT_ORG_DIV_3
SECTION DIV_4
org CRT_ORG_DIV_4
SECTION DIV_5
org CRT_ORG_DIV_5
SECTION DIV_6
org CRT_ORG_DIV_6
SECTION DIV_7
org CRT_ORG_DIV_7
SECTION DIV_8
org CRT_ORG_DIV_8
SECTION DIV_9
org CRT_ORG_DIV_9
SECTION DIV_10
org CRT_ORG_DIV_10
SECTION DIV_11
org CRT_ORG_DIV_11
SECTION DIV_12
org CRT_ORG_DIV_12
SECTION DIV_13
org CRT_ORG_DIV_13
SECTION DIV_14
org CRT_ORG_DIV_14
SECTION DIV_15
org CRT_ORG_DIV_15
SECTION UNASSIGNED
org 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ENDIF
IF __MMAP = 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; nextos extended dot command ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
INCLUDE "crt_memory_model_dotn.inc"
SECTION BANK_0
org CRT_ORG_BANK_0
SECTION BANK_0_L
org CRT_ORG_BANK_0_L
SECTION BANK_0_H
org CRT_ORG_BANK_0_H
SECTION BANK_1
org CRT_ORG_BANK_1
SECTION BANK_1_L
org CRT_ORG_BANK_1_L
SECTION BANK_1_H
org CRT_ORG_BANK_1_H
SECTION BANK_2
org CRT_ORG_BANK_2
SECTION BANK_2_L
org CRT_ORG_BANK_2_L
SECTION BANK_2_H
org CRT_ORG_BANK_2_H
SECTION BANK_3
org CRT_ORG_BANK_3
SECTION BANK_3_L
org CRT_ORG_BANK_3_L
SECTION BANK_3_H
org CRT_ORG_BANK_3_H
SECTION BANK_4
org CRT_ORG_BANK_4
SECTION BANK_4_L
org CRT_ORG_BANK_4_L
SECTION BANK_4_H
org CRT_ORG_BANK_4_H
SECTION BANK_5
org CRT_ORG_BANK_5
SECTION BANK_5_L
org CRT_ORG_BANK_5_L
SECTION BANK_5_H
org CRT_ORG_BANK_5_H
SECTION BANK_6
org CRT_ORG_BANK_6
SECTION BANK_6_L
org CRT_ORG_BANK_6_L
SECTION BANK_6_H
org CRT_ORG_BANK_6_H
SECTION BANK_7
org CRT_ORG_BANK_7
SECTION BANK_7_L
org CRT_ORG_BANK_7_L
SECTION BANK_7_H
org CRT_ORG_BANK_7_H
SECTION BANK_8
org CRT_ORG_BANK_8
SECTION BANK_8_L
org CRT_ORG_BANK_8_L
SECTION BANK_8_H
org CRT_ORG_BANK_8_H
SECTION BANK_9
org CRT_ORG_BANK_9
SECTION BANK_9_L
org CRT_ORG_BANK_9_L
SECTION BANK_9_H
org CRT_ORG_BANK_9_H
SECTION BANK_10
org CRT_ORG_BANK_10
SECTION BANK_10_L
org CRT_ORG_BANK_10_L
SECTION BANK_10_H
org CRT_ORG_BANK_10_H
SECTION BANK_11
org CRT_ORG_BANK_11
SECTION BANK_11_L
org CRT_ORG_BANK_11_L
SECTION BANK_11_H
org CRT_ORG_BANK_11_H
SECTION BANK_12
org CRT_ORG_BANK_12
SECTION BANK_12_L
org CRT_ORG_BANK_12_L
SECTION BANK_12_H
org CRT_ORG_BANK_12_H
SECTION BANK_13
org CRT_ORG_BANK_13
SECTION BANK_13_L
org CRT_ORG_BANK_13_L
SECTION BANK_13_H
org CRT_ORG_BANK_13_H
SECTION BANK_14
org CRT_ORG_BANK_14
SECTION BANK_14_L
org CRT_ORG_BANK_14_L
SECTION BANK_14_H
org CRT_ORG_BANK_14_H
SECTION BANK_15
org CRT_ORG_BANK_15
SECTION BANK_15_L
org CRT_ORG_BANK_15_L
SECTION BANK_15_H
org CRT_ORG_BANK_15_H
SECTION BANK_16
org CRT_ORG_BANK_16
SECTION BANK_16_L
org CRT_ORG_BANK_16_L
SECTION BANK_16_H
org CRT_ORG_BANK_16_H
SECTION BANK_17
org CRT_ORG_BANK_17
SECTION BANK_17_L
org CRT_ORG_BANK_17_L
SECTION BANK_17_H
org CRT_ORG_BANK_17_H
SECTION BANK_18
org CRT_ORG_BANK_18
SECTION BANK_18_L
org CRT_ORG_BANK_18_L
SECTION BANK_18_H
org CRT_ORG_BANK_18_H
SECTION BANK_19
org CRT_ORG_BANK_19
SECTION BANK_19_L
org CRT_ORG_BANK_19_L
SECTION BANK_19_H
org CRT_ORG_BANK_19_H
SECTION BANK_20
org CRT_ORG_BANK_20
SECTION BANK_20_L
org CRT_ORG_BANK_20_L
SECTION BANK_20_H
org CRT_ORG_BANK_20_H
SECTION BANK_21
org CRT_ORG_BANK_21
SECTION BANK_21_L
org CRT_ORG_BANK_21_L
SECTION BANK_21_H
org CRT_ORG_BANK_21_H
SECTION BANK_22
org CRT_ORG_BANK_22
SECTION BANK_22_L
org CRT_ORG_BANK_22_L
SECTION BANK_22_H
org CRT_ORG_BANK_22_H
SECTION BANK_23
org CRT_ORG_BANK_23
SECTION BANK_23_L
org CRT_ORG_BANK_23_L
SECTION BANK_23_H
org CRT_ORG_BANK_23_H
SECTION BANK_24
org CRT_ORG_BANK_24
SECTION BANK_24_L
org CRT_ORG_BANK_24_L
SECTION BANK_24_H
org CRT_ORG_BANK_24_H
SECTION BANK_25
org CRT_ORG_BANK_25
SECTION BANK_25_L
org CRT_ORG_BANK_25_L
SECTION BANK_25_H
org CRT_ORG_BANK_25_H
SECTION BANK_26
org CRT_ORG_BANK_26
SECTION BANK_26_L
org CRT_ORG_BANK_26_L
SECTION BANK_26_H
org CRT_ORG_BANK_26_H
SECTION BANK_27
org CRT_ORG_BANK_27
SECTION BANK_27_L
org CRT_ORG_BANK_27_L
SECTION BANK_27_H
org CRT_ORG_BANK_27_H
SECTION BANK_28
org CRT_ORG_BANK_28
SECTION BANK_28_L
org CRT_ORG_BANK_28_L
SECTION BANK_28_H
org CRT_ORG_BANK_28_H
SECTION BANK_29
org CRT_ORG_BANK_29
SECTION BANK_29_L
org CRT_ORG_BANK_29_L
SECTION BANK_29_H
org CRT_ORG_BANK_29_H
SECTION BANK_30
org CRT_ORG_BANK_30
SECTION BANK_30_L
org CRT_ORG_BANK_30_L
SECTION BANK_30_H
org CRT_ORG_BANK_30_H
SECTION BANK_31
org CRT_ORG_BANK_31
SECTION BANK_31_L
org CRT_ORG_BANK_31_L
SECTION BANK_31_H
org CRT_ORG_BANK_31_H
SECTION BANK_32
org CRT_ORG_BANK_32
SECTION BANK_32_L
org CRT_ORG_BANK_32_L
SECTION BANK_32_H
org CRT_ORG_BANK_32_H
SECTION BANK_33
org CRT_ORG_BANK_33
SECTION BANK_33_L
org CRT_ORG_BANK_33_L
SECTION BANK_33_H
org CRT_ORG_BANK_33_H
SECTION BANK_34
org CRT_ORG_BANK_34
SECTION BANK_34_L
org CRT_ORG_BANK_34_L
SECTION BANK_34_H
org CRT_ORG_BANK_34_H
SECTION BANK_35
org CRT_ORG_BANK_35
SECTION BANK_35_L
org CRT_ORG_BANK_35_L
SECTION BANK_35_H
org CRT_ORG_BANK_35_H
SECTION BANK_36
org CRT_ORG_BANK_36
SECTION BANK_36_L
org CRT_ORG_BANK_36_L
SECTION BANK_36_H
org CRT_ORG_BANK_36_H
SECTION BANK_37
org CRT_ORG_BANK_37
SECTION BANK_37_L
org CRT_ORG_BANK_37_L
SECTION BANK_37_H
org CRT_ORG_BANK_37_H
SECTION BANK_38
org CRT_ORG_BANK_38
SECTION BANK_38_L
org CRT_ORG_BANK_38_L
SECTION BANK_38_H
org CRT_ORG_BANK_38_H
SECTION BANK_39
org CRT_ORG_BANK_39
SECTION BANK_39_L
org CRT_ORG_BANK_39_L
SECTION BANK_39_H
org CRT_ORG_BANK_39_H
SECTION BANK_40
org CRT_ORG_BANK_40
SECTION BANK_40_L
org CRT_ORG_BANK_40_L
SECTION BANK_40_H
org CRT_ORG_BANK_40_H
SECTION BANK_41
org CRT_ORG_BANK_41
SECTION BANK_41_L
org CRT_ORG_BANK_41_L
SECTION BANK_41_H
org CRT_ORG_BANK_41_H
SECTION BANK_42
org CRT_ORG_BANK_42
SECTION BANK_42_L
org CRT_ORG_BANK_42_L
SECTION BANK_42_H
org CRT_ORG_BANK_42_H
SECTION BANK_43
org CRT_ORG_BANK_43
SECTION BANK_43_L
org CRT_ORG_BANK_43_L
SECTION BANK_43_H
org CRT_ORG_BANK_43_H
SECTION BANK_44
org CRT_ORG_BANK_44
SECTION BANK_44_L
org CRT_ORG_BANK_44_L
SECTION BANK_44_H
org CRT_ORG_BANK_44_H
SECTION BANK_45
org CRT_ORG_BANK_45
SECTION BANK_45_L
org CRT_ORG_BANK_45_L
SECTION BANK_45_H
org CRT_ORG_BANK_45_H
SECTION BANK_46
org CRT_ORG_BANK_46
SECTION BANK_46_L
org CRT_ORG_BANK_46_L
SECTION BANK_46_H
org CRT_ORG_BANK_46_H
SECTION BANK_47
org CRT_ORG_BANK_47
SECTION BANK_47_L
org CRT_ORG_BANK_47_L
SECTION BANK_47_H
org CRT_ORG_BANK_47_H
SECTION BANK_48
org CRT_ORG_BANK_48
SECTION BANK_48_L
org CRT_ORG_BANK_48_L
SECTION BANK_48_H
org CRT_ORG_BANK_48_H
SECTION BANK_49
org CRT_ORG_BANK_49
SECTION BANK_49_L
org CRT_ORG_BANK_49_L
SECTION BANK_49_H
org CRT_ORG_BANK_49_H
SECTION BANK_50
org CRT_ORG_BANK_50
SECTION BANK_50_L
org CRT_ORG_BANK_50_L
SECTION BANK_50_H
org CRT_ORG_BANK_50_H
SECTION BANK_51
org CRT_ORG_BANK_51
SECTION BANK_51_L
org CRT_ORG_BANK_51_L
SECTION BANK_51_H
org CRT_ORG_BANK_51_H
SECTION BANK_52
org CRT_ORG_BANK_52
SECTION BANK_52_L
org CRT_ORG_BANK_52_L
SECTION BANK_52_H
org CRT_ORG_BANK_52_H
SECTION BANK_53
org CRT_ORG_BANK_53
SECTION BANK_53_L
org CRT_ORG_BANK_53_L
SECTION BANK_53_H
org CRT_ORG_BANK_53_H
SECTION BANK_54
org CRT_ORG_BANK_54
SECTION BANK_54_L
org CRT_ORG_BANK_54_L
SECTION BANK_54_H
org CRT_ORG_BANK_54_H
SECTION BANK_55
org CRT_ORG_BANK_55
SECTION BANK_55_L
org CRT_ORG_BANK_55_L
SECTION BANK_55_H
org CRT_ORG_BANK_55_H
SECTION BANK_56
org CRT_ORG_BANK_56
SECTION BANK_56_L
org CRT_ORG_BANK_56_L
SECTION BANK_56_H
org CRT_ORG_BANK_56_H
SECTION BANK_57
org CRT_ORG_BANK_57
SECTION BANK_57_L
org CRT_ORG_BANK_57_L
SECTION BANK_57_H
org CRT_ORG_BANK_57_H
SECTION BANK_58
org CRT_ORG_BANK_58
SECTION BANK_58_L
org CRT_ORG_BANK_58_L
SECTION BANK_58_H
org CRT_ORG_BANK_58_H
SECTION BANK_59
org CRT_ORG_BANK_59
SECTION BANK_59_L
org CRT_ORG_BANK_59_L
SECTION BANK_59_H
org CRT_ORG_BANK_59_H
SECTION BANK_60
org CRT_ORG_BANK_60
SECTION BANK_60_L
org CRT_ORG_BANK_60_L
SECTION BANK_60_H
org CRT_ORG_BANK_60_H
SECTION BANK_61
org CRT_ORG_BANK_61
SECTION BANK_61_L
org CRT_ORG_BANK_61_L
SECTION BANK_61_H
org CRT_ORG_BANK_61_H
SECTION BANK_62
org CRT_ORG_BANK_62
SECTION BANK_62_L
org CRT_ORG_BANK_62_L
SECTION BANK_62_H
org CRT_ORG_BANK_62_H
SECTION BANK_63
org CRT_ORG_BANK_63
SECTION BANK_63_L
org CRT_ORG_BANK_63_L
SECTION BANK_63_H
org CRT_ORG_BANK_63_H
SECTION BANK_64
org CRT_ORG_BANK_64
SECTION BANK_64_L
org CRT_ORG_BANK_64_L
SECTION BANK_64_H
org CRT_ORG_BANK_64_H
SECTION BANK_65
org CRT_ORG_BANK_65
SECTION BANK_65_L
org CRT_ORG_BANK_65_L
SECTION BANK_65_H
org CRT_ORG_BANK_65_H
SECTION BANK_66
org CRT_ORG_BANK_66
SECTION BANK_66_L
org CRT_ORG_BANK_66_L
SECTION BANK_66_H
org CRT_ORG_BANK_66_H
SECTION BANK_67
org CRT_ORG_BANK_67
SECTION BANK_67_L
org CRT_ORG_BANK_67_L
SECTION BANK_67_H
org CRT_ORG_BANK_67_H
SECTION BANK_68
org CRT_ORG_BANK_68
SECTION BANK_68_L
org CRT_ORG_BANK_68_L
SECTION BANK_68_H
org CRT_ORG_BANK_68_H
SECTION BANK_69
org CRT_ORG_BANK_69
SECTION BANK_69_L
org CRT_ORG_BANK_69_L
SECTION BANK_69_H
org CRT_ORG_BANK_69_H
SECTION BANK_70
org CRT_ORG_BANK_70
SECTION BANK_70_L
org CRT_ORG_BANK_70_L
SECTION BANK_70_H
org CRT_ORG_BANK_70_H
SECTION BANK_71
org CRT_ORG_BANK_71
SECTION BANK_71_L
org CRT_ORG_BANK_71_L
SECTION BANK_71_H
org CRT_ORG_BANK_71_H
SECTION BANK_72
org CRT_ORG_BANK_72
SECTION BANK_72_L
org CRT_ORG_BANK_72_L
SECTION BANK_72_H
org CRT_ORG_BANK_72_H
SECTION BANK_73
org CRT_ORG_BANK_73
SECTION BANK_73_L
org CRT_ORG_BANK_73_L
SECTION BANK_73_H
org CRT_ORG_BANK_73_H
SECTION BANK_74
org CRT_ORG_BANK_74
SECTION BANK_74_L
org CRT_ORG_BANK_74_L
SECTION BANK_74_H
org CRT_ORG_BANK_74_H
SECTION BANK_75
org CRT_ORG_BANK_75
SECTION BANK_75_L
org CRT_ORG_BANK_75_L
SECTION BANK_75_H
org CRT_ORG_BANK_75_H
SECTION BANK_76
org CRT_ORG_BANK_76
SECTION BANK_76_L
org CRT_ORG_BANK_76_L
SECTION BANK_76_H
org CRT_ORG_BANK_76_H
SECTION BANK_77
org CRT_ORG_BANK_77
SECTION BANK_77_L
org CRT_ORG_BANK_77_L
SECTION BANK_77_H
org CRT_ORG_BANK_77_H
SECTION BANK_78
org CRT_ORG_BANK_78
SECTION BANK_78_L
org CRT_ORG_BANK_78_L
SECTION BANK_78_H
org CRT_ORG_BANK_78_H
SECTION BANK_79
org CRT_ORG_BANK_79
SECTION BANK_79_L
org CRT_ORG_BANK_79_L
SECTION BANK_79_H
org CRT_ORG_BANK_79_H
SECTION BANK_80
org CRT_ORG_BANK_80
SECTION BANK_80_L
org CRT_ORG_BANK_80_L
SECTION BANK_80_H
org CRT_ORG_BANK_80_H
SECTION BANK_81
org CRT_ORG_BANK_81
SECTION BANK_81_L
org CRT_ORG_BANK_81_L
SECTION BANK_81_H
org CRT_ORG_BANK_81_H
SECTION BANK_82
org CRT_ORG_BANK_82
SECTION BANK_82_L
org CRT_ORG_BANK_82_L
SECTION BANK_82_H
org CRT_ORG_BANK_82_H
SECTION BANK_83
org CRT_ORG_BANK_83
SECTION BANK_83_L
org CRT_ORG_BANK_83_L
SECTION BANK_83_H
org CRT_ORG_BANK_83_H
SECTION BANK_84
org CRT_ORG_BANK_84
SECTION BANK_84_L
org CRT_ORG_BANK_84_L
SECTION BANK_84_H
org CRT_ORG_BANK_84_H
SECTION BANK_85
org CRT_ORG_BANK_85
SECTION BANK_85_L
org CRT_ORG_BANK_85_L
SECTION BANK_85_H
org CRT_ORG_BANK_85_H
SECTION BANK_86
org CRT_ORG_BANK_86
SECTION BANK_86_L
org CRT_ORG_BANK_86_L
SECTION BANK_86_H
org CRT_ORG_BANK_86_H
SECTION BANK_87
org CRT_ORG_BANK_87
SECTION BANK_87_L
org CRT_ORG_BANK_87_L
SECTION BANK_87_H
org CRT_ORG_BANK_87_H
SECTION BANK_88
org CRT_ORG_BANK_88
SECTION BANK_88_L
org CRT_ORG_BANK_88_L
SECTION BANK_88_H
org CRT_ORG_BANK_88_H
SECTION BANK_89
org CRT_ORG_BANK_89
SECTION BANK_89_L
org CRT_ORG_BANK_89_L
SECTION BANK_89_H
org CRT_ORG_BANK_89_H
SECTION BANK_90
org CRT_ORG_BANK_90
SECTION BANK_90_L
org CRT_ORG_BANK_90_L
SECTION BANK_90_H
org CRT_ORG_BANK_90_H
SECTION BANK_91
org CRT_ORG_BANK_91
SECTION BANK_91_L
org CRT_ORG_BANK_91_L
SECTION BANK_91_H
org CRT_ORG_BANK_91_H
SECTION BANK_92
org CRT_ORG_BANK_92
SECTION BANK_92_L
org CRT_ORG_BANK_92_L
SECTION BANK_92_H
org CRT_ORG_BANK_92_H
SECTION BANK_93
org CRT_ORG_BANK_93
SECTION BANK_93_L
org CRT_ORG_BANK_93_L
SECTION BANK_93_H
org CRT_ORG_BANK_93_H
SECTION BANK_94
org CRT_ORG_BANK_94
SECTION BANK_94_L
org CRT_ORG_BANK_94_L
SECTION BANK_94_H
org CRT_ORG_BANK_94_H
SECTION BANK_95
org CRT_ORG_BANK_95
SECTION BANK_95_L
org CRT_ORG_BANK_95_L
SECTION BANK_95_H
org CRT_ORG_BANK_95_H
SECTION BANK_96
org CRT_ORG_BANK_96
SECTION BANK_96_L
org CRT_ORG_BANK_96_L
SECTION BANK_96_H
org CRT_ORG_BANK_96_H
SECTION BANK_97
org CRT_ORG_BANK_97
SECTION BANK_97_L
org CRT_ORG_BANK_97_L
SECTION BANK_97_H
org CRT_ORG_BANK_97_H
SECTION BANK_98
org CRT_ORG_BANK_98
SECTION BANK_98_L
org CRT_ORG_BANK_98_L
SECTION BANK_98_H
org CRT_ORG_BANK_98_H
SECTION BANK_99
org CRT_ORG_BANK_99
SECTION BANK_99_L
org CRT_ORG_BANK_99_L
SECTION BANK_99_H
org CRT_ORG_BANK_99_H
SECTION BANK_100
org CRT_ORG_BANK_100
SECTION BANK_100_L
org CRT_ORG_BANK_100_L
SECTION BANK_100_H
org CRT_ORG_BANK_100_H
SECTION BANK_101
org CRT_ORG_BANK_101
SECTION BANK_101_L
org CRT_ORG_BANK_101_L
SECTION BANK_101_H
org CRT_ORG_BANK_101_H
SECTION BANK_102
org CRT_ORG_BANK_102
SECTION BANK_102_L
org CRT_ORG_BANK_102_L
SECTION BANK_102_H
org CRT_ORG_BANK_102_H
SECTION BANK_103
org CRT_ORG_BANK_103
SECTION BANK_103_L
org CRT_ORG_BANK_103_L
SECTION BANK_103_H
org CRT_ORG_BANK_103_H
SECTION BANK_104
org CRT_ORG_BANK_104
SECTION BANK_104_L
org CRT_ORG_BANK_104_L
SECTION BANK_104_H
org CRT_ORG_BANK_104_H
SECTION BANK_105
org CRT_ORG_BANK_105
SECTION BANK_105_L
org CRT_ORG_BANK_105_L
SECTION BANK_105_H
org CRT_ORG_BANK_105_H
SECTION BANK_106
org CRT_ORG_BANK_106
SECTION BANK_106_L
org CRT_ORG_BANK_106_L
SECTION BANK_106_H
org CRT_ORG_BANK_106_H
SECTION BANK_107
org CRT_ORG_BANK_107
SECTION BANK_107_L
org CRT_ORG_BANK_107_L
SECTION BANK_107_H
org CRT_ORG_BANK_107_H
SECTION BANK_108
org CRT_ORG_BANK_108
SECTION BANK_108_L
org CRT_ORG_BANK_108_L
SECTION BANK_108_H
org CRT_ORG_BANK_108_H
SECTION BANK_109
org CRT_ORG_BANK_109
SECTION BANK_109_L
org CRT_ORG_BANK_109_L
SECTION BANK_109_H
org CRT_ORG_BANK_109_H
SECTION BANK_110
org CRT_ORG_BANK_110
SECTION BANK_110_L
org CRT_ORG_BANK_110_L
SECTION BANK_110_H
org CRT_ORG_BANK_110_H
SECTION BANK_111
org CRT_ORG_BANK_111
SECTION BANK_111_L
org CRT_ORG_BANK_111_L
SECTION BANK_111_H
org CRT_ORG_BANK_111_H
SECTION PAGE_0
org CRT_ORG_PAGE_0
SECTION PAGE_1
org CRT_ORG_PAGE_1
SECTION PAGE_2
org CRT_ORG_PAGE_2
SECTION PAGE_3
org CRT_ORG_PAGE_3
SECTION PAGE_4
org CRT_ORG_PAGE_4
SECTION PAGE_5
org CRT_ORG_PAGE_5
SECTION PAGE_6
org CRT_ORG_PAGE_6
SECTION PAGE_7
org CRT_ORG_PAGE_7
SECTION PAGE_8
org CRT_ORG_PAGE_8
SECTION PAGE_9
org CRT_ORG_PAGE_9
SECTION PAGE_10
org CRT_ORG_PAGE_10
SECTION PAGE_11
org CRT_ORG_PAGE_11
SECTION PAGE_12
org CRT_ORG_PAGE_12
SECTION PAGE_13
org CRT_ORG_PAGE_13
SECTION PAGE_14
org CRT_ORG_PAGE_14
SECTION PAGE_15
org CRT_ORG_PAGE_15
SECTION PAGE_16
org CRT_ORG_PAGE_16
SECTION PAGE_17
org CRT_ORG_PAGE_17
SECTION PAGE_18
org CRT_ORG_PAGE_18
SECTION PAGE_19
org CRT_ORG_PAGE_19
SECTION PAGE_20
org CRT_ORG_PAGE_20
SECTION PAGE_21
org CRT_ORG_PAGE_21
SECTION PAGE_22
org CRT_ORG_PAGE_22
SECTION PAGE_23
org CRT_ORG_PAGE_23
SECTION PAGE_24
org CRT_ORG_PAGE_24
SECTION PAGE_25
org CRT_ORG_PAGE_25
SECTION PAGE_26
org CRT_ORG_PAGE_26
SECTION PAGE_27
org CRT_ORG_PAGE_27
SECTION PAGE_28
org CRT_ORG_PAGE_28
SECTION PAGE_29
org CRT_ORG_PAGE_29
SECTION PAGE_30
org CRT_ORG_PAGE_30
SECTION PAGE_31
org CRT_ORG_PAGE_31
SECTION PAGE_32
org CRT_ORG_PAGE_32
SECTION PAGE_33
org CRT_ORG_PAGE_33
SECTION PAGE_34
org CRT_ORG_PAGE_34
SECTION PAGE_35
org CRT_ORG_PAGE_35
SECTION PAGE_36
org CRT_ORG_PAGE_36
SECTION PAGE_37
org CRT_ORG_PAGE_37
SECTION PAGE_38
org CRT_ORG_PAGE_38
SECTION PAGE_39
org CRT_ORG_PAGE_39
SECTION PAGE_40
org CRT_ORG_PAGE_40
SECTION PAGE_41
org CRT_ORG_PAGE_41
SECTION PAGE_42
org CRT_ORG_PAGE_42
SECTION PAGE_43
org CRT_ORG_PAGE_43
SECTION PAGE_44
org CRT_ORG_PAGE_44
SECTION PAGE_45
org CRT_ORG_PAGE_45
SECTION PAGE_46
org CRT_ORG_PAGE_46
SECTION PAGE_47
org CRT_ORG_PAGE_47
SECTION PAGE_48
org CRT_ORG_PAGE_48
SECTION PAGE_49
org CRT_ORG_PAGE_49
SECTION PAGE_50
org CRT_ORG_PAGE_50
SECTION PAGE_51
org CRT_ORG_PAGE_51
SECTION PAGE_52
org CRT_ORG_PAGE_52
SECTION PAGE_53
org CRT_ORG_PAGE_53
SECTION PAGE_54
org CRT_ORG_PAGE_54
SECTION PAGE_55
org CRT_ORG_PAGE_55
SECTION PAGE_56
org CRT_ORG_PAGE_56
SECTION PAGE_57
org CRT_ORG_PAGE_57
SECTION PAGE_58
org CRT_ORG_PAGE_58
SECTION PAGE_59
org CRT_ORG_PAGE_59
SECTION PAGE_60
org CRT_ORG_PAGE_60
SECTION PAGE_61
org CRT_ORG_PAGE_61
SECTION PAGE_62
org CRT_ORG_PAGE_62
SECTION PAGE_63
org CRT_ORG_PAGE_63
SECTION PAGE_64
org CRT_ORG_PAGE_64
SECTION PAGE_65
org CRT_ORG_PAGE_65
SECTION PAGE_66
org CRT_ORG_PAGE_66
SECTION PAGE_67
org CRT_ORG_PAGE_67
SECTION PAGE_68
org CRT_ORG_PAGE_68
SECTION PAGE_69
org CRT_ORG_PAGE_69
SECTION PAGE_70
org CRT_ORG_PAGE_70
SECTION PAGE_71
org CRT_ORG_PAGE_71
SECTION PAGE_72
org CRT_ORG_PAGE_72
SECTION PAGE_73
org CRT_ORG_PAGE_73
SECTION PAGE_74
org CRT_ORG_PAGE_74
SECTION PAGE_75
org CRT_ORG_PAGE_75
SECTION PAGE_76
org CRT_ORG_PAGE_76
SECTION PAGE_77
org CRT_ORG_PAGE_77
SECTION PAGE_78
org CRT_ORG_PAGE_78
SECTION PAGE_79
org CRT_ORG_PAGE_79
SECTION PAGE_80
org CRT_ORG_PAGE_80
SECTION PAGE_81
org CRT_ORG_PAGE_81
SECTION PAGE_82
org CRT_ORG_PAGE_82
SECTION PAGE_83
org CRT_ORG_PAGE_83
SECTION PAGE_84
org CRT_ORG_PAGE_84
SECTION PAGE_85
org CRT_ORG_PAGE_85
SECTION PAGE_86
org CRT_ORG_PAGE_86
SECTION PAGE_87
org CRT_ORG_PAGE_87
SECTION PAGE_88
org CRT_ORG_PAGE_88
SECTION PAGE_89
org CRT_ORG_PAGE_89
SECTION PAGE_90
org CRT_ORG_PAGE_90
SECTION PAGE_91
org CRT_ORG_PAGE_91
SECTION PAGE_92
org CRT_ORG_PAGE_92
SECTION PAGE_93
org CRT_ORG_PAGE_93
SECTION PAGE_94
org CRT_ORG_PAGE_94
SECTION PAGE_95
org CRT_ORG_PAGE_95
SECTION PAGE_96
org CRT_ORG_PAGE_96
SECTION PAGE_97
org CRT_ORG_PAGE_97
SECTION PAGE_98
org CRT_ORG_PAGE_98
SECTION PAGE_99
org CRT_ORG_PAGE_99
SECTION PAGE_100
org CRT_ORG_PAGE_100
SECTION PAGE_101
org CRT_ORG_PAGE_101
SECTION PAGE_102
org CRT_ORG_PAGE_102
SECTION PAGE_103
org CRT_ORG_PAGE_103
SECTION PAGE_104
org CRT_ORG_PAGE_104
SECTION PAGE_105
org CRT_ORG_PAGE_105
SECTION PAGE_106
org CRT_ORG_PAGE_106
SECTION PAGE_107
org CRT_ORG_PAGE_107
SECTION PAGE_108
org CRT_ORG_PAGE_108
SECTION PAGE_109
org CRT_ORG_PAGE_109
SECTION PAGE_110
org CRT_ORG_PAGE_110
SECTION PAGE_111
org CRT_ORG_PAGE_111
SECTION PAGE_112
org CRT_ORG_PAGE_112
SECTION PAGE_113
org CRT_ORG_PAGE_113
SECTION PAGE_114
org CRT_ORG_PAGE_114
SECTION PAGE_115
org CRT_ORG_PAGE_115
SECTION PAGE_116
org CRT_ORG_PAGE_116
SECTION PAGE_117
org CRT_ORG_PAGE_117
SECTION PAGE_118
org CRT_ORG_PAGE_118
SECTION PAGE_119
org CRT_ORG_PAGE_119
SECTION PAGE_120
org CRT_ORG_PAGE_120
SECTION PAGE_121
org CRT_ORG_PAGE_121
SECTION PAGE_122
org CRT_ORG_PAGE_122
SECTION PAGE_123
org CRT_ORG_PAGE_123
SECTION PAGE_124
org CRT_ORG_PAGE_124
SECTION PAGE_125
org CRT_ORG_PAGE_125
SECTION PAGE_126
org CRT_ORG_PAGE_126
SECTION PAGE_127
org CRT_ORG_PAGE_127
SECTION PAGE_128
org CRT_ORG_PAGE_128
SECTION PAGE_129
org CRT_ORG_PAGE_129
SECTION PAGE_130
org CRT_ORG_PAGE_130
SECTION PAGE_131
org CRT_ORG_PAGE_131
SECTION PAGE_132
org CRT_ORG_PAGE_132
SECTION PAGE_133
org CRT_ORG_PAGE_133
SECTION PAGE_134
org CRT_ORG_PAGE_134
SECTION PAGE_135
org CRT_ORG_PAGE_135
SECTION PAGE_136
org CRT_ORG_PAGE_136
SECTION PAGE_137
org CRT_ORG_PAGE_137
SECTION PAGE_138
org CRT_ORG_PAGE_138
SECTION PAGE_139
org CRT_ORG_PAGE_139
SECTION PAGE_140
org CRT_ORG_PAGE_140
SECTION PAGE_141
org CRT_ORG_PAGE_141
SECTION PAGE_142
org CRT_ORG_PAGE_142
SECTION PAGE_143
org CRT_ORG_PAGE_143
SECTION PAGE_144
org CRT_ORG_PAGE_144
SECTION PAGE_145
org CRT_ORG_PAGE_145
SECTION PAGE_146
org CRT_ORG_PAGE_146
SECTION PAGE_147
org CRT_ORG_PAGE_147
SECTION PAGE_148
org CRT_ORG_PAGE_148
SECTION PAGE_149
org CRT_ORG_PAGE_149
SECTION PAGE_150
org CRT_ORG_PAGE_150
SECTION PAGE_151
org CRT_ORG_PAGE_151
SECTION PAGE_152
org CRT_ORG_PAGE_152
SECTION PAGE_153
org CRT_ORG_PAGE_153
SECTION PAGE_154
org CRT_ORG_PAGE_154
SECTION PAGE_155
org CRT_ORG_PAGE_155
SECTION PAGE_156
org CRT_ORG_PAGE_156
SECTION PAGE_157
org CRT_ORG_PAGE_157
SECTION PAGE_158
org CRT_ORG_PAGE_158
SECTION PAGE_159
org CRT_ORG_PAGE_159
SECTION PAGE_160
org CRT_ORG_PAGE_160
SECTION PAGE_161
org CRT_ORG_PAGE_161
SECTION PAGE_162
org CRT_ORG_PAGE_162
SECTION PAGE_163
org CRT_ORG_PAGE_163
SECTION PAGE_164
org CRT_ORG_PAGE_164
SECTION PAGE_165
org CRT_ORG_PAGE_165
SECTION PAGE_166
org CRT_ORG_PAGE_166
SECTION PAGE_167
org CRT_ORG_PAGE_167
SECTION PAGE_168
org CRT_ORG_PAGE_168
SECTION PAGE_169
org CRT_ORG_PAGE_169
SECTION PAGE_170
org CRT_ORG_PAGE_170
SECTION PAGE_171
org CRT_ORG_PAGE_171
SECTION PAGE_172
org CRT_ORG_PAGE_172
SECTION PAGE_173
org CRT_ORG_PAGE_173
SECTION PAGE_174
org CRT_ORG_PAGE_174
SECTION PAGE_175
org CRT_ORG_PAGE_175
SECTION PAGE_176
org CRT_ORG_PAGE_176
SECTION PAGE_177
org CRT_ORG_PAGE_177
SECTION PAGE_178
org CRT_ORG_PAGE_178
SECTION PAGE_179
org CRT_ORG_PAGE_179
SECTION PAGE_180
org CRT_ORG_PAGE_180
SECTION PAGE_181
org CRT_ORG_PAGE_181
SECTION PAGE_182
org CRT_ORG_PAGE_182
SECTION PAGE_183
org CRT_ORG_PAGE_183
SECTION PAGE_184
org CRT_ORG_PAGE_184
SECTION PAGE_185
org CRT_ORG_PAGE_185
SECTION PAGE_186
org CRT_ORG_PAGE_186
SECTION PAGE_187
org CRT_ORG_PAGE_187
SECTION PAGE_188
org CRT_ORG_PAGE_188
SECTION PAGE_189
org CRT_ORG_PAGE_189
SECTION PAGE_190
org CRT_ORG_PAGE_190
SECTION PAGE_191
org CRT_ORG_PAGE_191
SECTION PAGE_192
org CRT_ORG_PAGE_192
SECTION PAGE_193
org CRT_ORG_PAGE_193
SECTION PAGE_194
org CRT_ORG_PAGE_194
SECTION PAGE_195
org CRT_ORG_PAGE_195
SECTION PAGE_196
org CRT_ORG_PAGE_196
SECTION PAGE_197
org CRT_ORG_PAGE_197
SECTION PAGE_198
org CRT_ORG_PAGE_198
SECTION PAGE_199
org CRT_ORG_PAGE_199
SECTION PAGE_200
org CRT_ORG_PAGE_200
SECTION PAGE_201
org CRT_ORG_PAGE_201
SECTION PAGE_202
org CRT_ORG_PAGE_202
SECTION PAGE_203
org CRT_ORG_PAGE_203
SECTION PAGE_204
org CRT_ORG_PAGE_204
SECTION PAGE_205
org CRT_ORG_PAGE_205
SECTION PAGE_206
org CRT_ORG_PAGE_206
SECTION PAGE_207
org CRT_ORG_PAGE_207
SECTION PAGE_208
org CRT_ORG_PAGE_208
SECTION PAGE_209
org CRT_ORG_PAGE_209
SECTION PAGE_210
org CRT_ORG_PAGE_210
SECTION PAGE_211
org CRT_ORG_PAGE_211
SECTION PAGE_212
org CRT_ORG_PAGE_212
SECTION PAGE_213
org CRT_ORG_PAGE_213
SECTION PAGE_214
org CRT_ORG_PAGE_214
SECTION PAGE_215
org CRT_ORG_PAGE_215
SECTION PAGE_216
org CRT_ORG_PAGE_216
SECTION PAGE_217
org CRT_ORG_PAGE_217
SECTION PAGE_218
org CRT_ORG_PAGE_218
SECTION PAGE_219
org CRT_ORG_PAGE_219
SECTION PAGE_220
org CRT_ORG_PAGE_220
SECTION PAGE_221
org CRT_ORG_PAGE_221
SECTION PAGE_222
org CRT_ORG_PAGE_222
SECTION PAGE_223
org CRT_ORG_PAGE_223
SECTION DIV_0
org CRT_ORG_DIV_0
SECTION DIV_1
org CRT_ORG_DIV_1
SECTION DIV_2
org CRT_ORG_DIV_2
SECTION DIV_3
org CRT_ORG_DIV_3
SECTION DIV_4
org CRT_ORG_DIV_4
SECTION DIV_5
org CRT_ORG_DIV_5
SECTION DIV_6
org CRT_ORG_DIV_6
SECTION DIV_7
org CRT_ORG_DIV_7
SECTION DIV_8
org CRT_ORG_DIV_8
SECTION DIV_9
org CRT_ORG_DIV_9
SECTION DIV_10
org CRT_ORG_DIV_10
SECTION DIV_11
org CRT_ORG_DIV_11
SECTION DIV_12
org CRT_ORG_DIV_12
SECTION DIV_13
org CRT_ORG_DIV_13
SECTION DIV_14
org CRT_ORG_DIV_14
SECTION DIV_15
org CRT_ORG_DIV_15
SECTION UNASSIGNED
org 0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ENDIF
;; end memory model ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; INSTANTIATE DRIVERS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ifndef CRT_OTERM_FONT_8X8
PUBLIC CRT_OTERM_FONT_8X8
EXTERN _font_8x8_rom
defc CRT_OTERM_FONT_8X8 = _font_8x8_rom
endif
; When FILEs and FDSTRUCTs are instantiated labels are assigned
; to point at created structures.
;
; The label formats are:
;
; __i_stdio_file_n = address of static FILE structure #n (0..__I_STDIO_NUM_FILE-1)
; __i_fcntl_fdstruct_n = address of static FDSTRUCT #n (0..__I_FCNTL_NUM_FD-1)
; __i_fcntl_heap_n = address of allocation #n on heap (0..__I_FCNTL_NUM_HEAP-1)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FILE : _stdin
;
; driver: zx_01_input_kbd_inkey
; fd : 0
; mode : read only
; type : 001 = input terminal
; tie : __i_fcntl_fdstruct_1
;
; ioctl_flags : CRT_ITERM_TERMINAL_FLAGS
; buffer size : 64 bytes
; debounce : CRT_ITERM_INKEY_DEBOUNCE ms
; repeat_start : CRT_ITERM_INKEY_REPEAT_START ms
; repeat_period : CRT_ITERM_INKEY_REPEAT_RATE ms
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION data_clib
SECTION data_stdio
; FILE *
PUBLIC _stdin
_stdin: defw __i_stdio_file_0 + 2
; FILE structure
__i_stdio_file_0:
; open files link
defw 0
; jump to underlying fd
defb 195
defw __i_fcntl_fdstruct_0
; state_flags_0
; state_flags_1
; conversion flags
; ungetc
defb 0x40 ; read + stdio manages ungetc + normal file type
defb 0x02 ; last operation was read
defb 0
defb 0
; mtx_recursive
defb 0 ; thread owner = none
defb 0x02 ; mtx_recursive
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; fd table entry
SECTION data_fcntl_fdtable_body
defw __i_fcntl_fdstruct_0
; FDSTRUCT structure
SECTION data_fcntl_stdio_heap_body
EXTERN console_01_input_terminal_fdriver
EXTERN zx_01_input_kbd_inkey
__i_fcntl_heap_0:
; heap header
defw __i_fcntl_heap_1
defw 105
defw 0
__i_fcntl_fdstruct_0:
; FDSTRUCT structure
; call to first entry to driver
defb 205
defw console_01_input_terminal_fdriver
; jump to driver
defb 195
defw zx_01_input_kbd_inkey
; flags
; reference_count
; mode_byte
defb 0x01 ; stdio handles ungetc + type = input terminal
defb 2
defb 0x01 ; read only
; ioctl_flags
defw CRT_ITERM_TERMINAL_FLAGS
; mtx_plain
defb 0 ; thread owner = none
defb 0x01 ; mtx_plain
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; tied output terminal
; pending_char
; read_index
defw __i_fcntl_fdstruct_1
defb 0
defw 0
; b_array_t edit_buffer
defw __edit_buffer_0
defw 0
defw 64
; getk_state
; getk_lastk
; getk_debounce_ms
; getk_repeatbegin_ms
; getk_repeatperiod_ms
defb 0
defb 0
defb CRT_ITERM_INKEY_DEBOUNCE
defw CRT_ITERM_INKEY_REPEAT_START
defw CRT_ITERM_INKEY_REPEAT_RATE
; reserve space for edit buffer
__edit_buffer_0: defs 64
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FILE : _stdout
;
; driver: zx_01_output_char_32
; fd : 1
; mode : write only
; type : 002 = output terminal
;
; ioctl_flags : CRT_OTERM_TERMINAL_FLAGS
; cursor coord : (0,0)
; window : (CRT_OTERM_WINDOW_X,CRT_OTERM_WINDOW_WIDTH,CRT_OTERM_WINDOW_Y,CRT_OTERM_WINDOW_HEIGHT)
; scroll limit : 0
; font address : CRT_OTERM_FONT_8X8
; text colour : CRT_OTERM_TEXT_COLOR
; text mask : CRT_OTERM_TEXT_COLOR_MASK
; background : CRT_OTERM_BACKGROUND_COLOR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION data_clib
SECTION data_stdio
; FILE *
PUBLIC _stdout
_stdout: defw __i_stdio_file_1 + 2
; FILE structure
__i_stdio_file_1:
; open files link
defw __i_stdio_file_0
; jump to underlying fd
defb 195
defw __i_fcntl_fdstruct_1
; state_flags_0
; state_flags_1
; conversion flags
; ungetc
defb 0x80 ; write + normal file type
defb 0 ; last operation was write
defb 0
defb 0
; mtx_recursive
defb 0 ; thread owner = none
defb 0x02 ; mtx_recursive
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; fd table entry
SECTION data_fcntl_fdtable_body
defw __i_fcntl_fdstruct_1
; FDSTRUCT structure
SECTION data_fcntl_stdio_heap_body
EXTERN console_01_output_terminal_fdriver
EXTERN zx_01_output_char_32
__i_fcntl_heap_1:
; heap header
defw __i_fcntl_heap_2
defw 35
defw __i_fcntl_heap_0
__i_fcntl_fdstruct_1:
; FDSTRUCT structure
; call to first entry to driver
defb 205
defw console_01_output_terminal_fdriver
; jump to driver
defb 195
defw zx_01_output_char_32
; flags
; reference_count
; mode_byte
defb 0x02 ; type = output terminal
defb 2
defb 0x02 ; write only
; ioctl_flags
defw CRT_OTERM_TERMINAL_FLAGS
; mtx_plain
defb 0 ; thread owner = none
defb 0x01 ; mtx_plain
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; cursor coordinate
; window rectangle
; scroll limit
defb 0, 0
defb CRT_OTERM_WINDOW_X, CRT_OTERM_WINDOW_WIDTH, CRT_OTERM_WINDOW_Y, CRT_OTERM_WINDOW_HEIGHT
defb 0
; font address
; text colour
; text mask
; background colour
EXTERN CRT_OTERM_FONT_8X8
defw CRT_OTERM_FONT_8X8 - 256
defb CRT_OTERM_TEXT_COLOR
defb CRT_OTERM_TEXT_COLOR_MASK
defb CRT_OTERM_BACKGROUND_COLOR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DUPED FILE DESCRIPTOR
;
; FILE : _stderr
; flags : 0x80
;
; fd : 2
; dup fd: __i_fcntl_fdstruct_1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION data_clib
SECTION data_stdio
; FILE *
PUBLIC _stderr
_stderr: defw __i_stdio_file_2 + 2
; FILE structure
__i_stdio_file_2:
; open files link
defw __i_stdio_file_1
; jump to duped fd
defb 195
defw __i_fcntl_fdstruct_1
; state_flags_0
; state_flags_1
; conversion flags
; ungetc
defb 0x80
defb 0
defb 0
defb 0
; mtx_recursive
defb 0 ; thread owner = none
defb 0x02 ; mtx_recursive
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; fd table entry
SECTION data_fcntl_fdtable_body
defw __i_fcntl_fdstruct_1
; FDSTRUCT structure
defc __i_fcntl_fdstruct_2 = __i_fcntl_fdstruct_1
; adjust reference count on duped FDSTRUCT
SECTION code_crt_init
ld hl,__i_fcntl_fdstruct_1 + 7 ; & FDSTRUCT.ref_count
inc (hl)
inc (hl)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; create open and closed FILE lists
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; __clib_fopen_max = max number of open FILEs specified by user
; 3 = number of static FILEs instantiated in crt
; __i_stdio_file_n = address of static FILE structure #n (0..I_STDIO_FILE_NUM-1)
PUBLIC __MAX_FOPEN
SECTION data_clib
SECTION data_stdio
IF (__clib_fopen_max > 0) || (3 > 0)
; number of FILEs > 0
; construct list of open files
IF 3 > 0
; number of FILEs statically generated > 0
SECTION data_clib
SECTION data_stdio
PUBLIC __stdio_open_file_list
__stdio_open_file_list: defw __i_stdio_file_2
ELSE
; number of FILEs statically generated = 0
SECTION bss_clib
SECTION bss_stdio
PUBLIC __stdio_open_file_list
__stdio_open_file_list: defw 0
ENDIF
; construct list of closed / available FILEs
SECTION data_clib
SECTION data_stdio
PUBLIC __stdio_closed_file_list
__stdio_closed_file_list: defw 0, __stdio_closed_file_list
IF __clib_fopen_max > 3
defc __MAX_FOPEN = __clib_fopen_max
; create extra FILE structures
SECTION bss_clib
SECTION bss_stdio
__stdio_file_extra: defs (__clib_fopen_max - 3) * 15
SECTION code_crt_init
ld bc,__stdio_closed_file_list
ld de,__stdio_file_extra
ld l,__clib_fopen_max - 3
loop:
push hl
EXTERN asm_p_forward_list_alt_push_front
call asm_p_forward_list_alt_push_front
ld de,15
add hl,de
ex de,hl
pop hl
dec l
jr nz, loop
ELSE
defc __MAX_FOPEN = 3
ENDIF
ENDIF
IF (__clib_fopen_max = 0) && (3 = 0)
defc __MAX_FOPEN = 0
; create empty file lists
SECTION bss_clib
SECTION bss_stdio
PUBLIC __stdio_open_file_list
__stdio_open_file_list: defw 0
SECTION data_clib
SECTION data_stdio
PUBLIC __stdio_closed_file_list
__stdio_closed_file_list: defw 0, __stdio_closed_file_list
ENDIF
IF (__clib_fopen_max < 0) && (3 = 0)
defc __MAX_FOPEN = 0
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; create fd table
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; __clib_open_max = max number of open fds specified by user
; 3 = number of static file descriptors created
PUBLIC __fcntl_fdtbl
PUBLIC __fcntl_fdtbl_size
IF 3 > 0
; create rest of fd table in data segment
SECTION data_fcntl_fdtable_body
EXTERN __data_fcntl_fdtable_body_head
defc __fcntl_fdtbl = __data_fcntl_fdtable_body_head
IF __clib_open_max > 3
SECTION data_fcntl_fdtable_body
defs (__clib_open_max - 3) * 2
defc __fcntl_fdtbl_size = __clib_open_max
ELSE
defc __fcntl_fdtbl_size = 3
ENDIF
ELSE
IF __clib_open_max > 0
; create fd table in bss segment
SECTION bss_clib
SECTION bss_fcntl
__fcntl_fdtbl: defs __clib_open_max * 2
ELSE
; no fd table at all
defc __fcntl_fdtbl = 0
ENDIF
defc __fcntl_fdtbl_size = __clib_open_max
ENDIF
PUBLIC __MAX_OPEN
defc __MAX_OPEN = __fcntl_fdtbl_size
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; finalize stdio heap
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; __clib_stdio_heap_size = desired stdio heap size in bytes
; 140 = byte size of static FDSTRUCTs
; 2 = number of heap allocations
; __i_fcntl_heap_n = address of allocation #n on heap (0..__I_FCNTL_NUM_HEAP-1)
IF 140 > 0
; static FDSTRUCTs have been allocated in the heap
SECTION data_clib
SECTION data_fcntl
PUBLIC __stdio_heap
__stdio_heap: defw __stdio_block
SECTION data_fcntl_stdio_heap_head
__stdio_block:
defb 0 ; no owner
defb 0x01 ; mtx_plain
defb 0 ; number of lock acquisitions
defb 0xfe ; spinlock (unlocked)
defw 0 ; list of threads blocked on mutex
IF __clib_stdio_heap_size > (140 + 14)
; expand stdio heap to desired size
SECTION data_fcntl_stdio_heap_body
__i_fcntl_heap_2:
defw __i_fcntl_heap_3
defw 0
defw __i_fcntl_heap_1
defs __clib_stdio_heap_size - 140 - 14
; terminate stdio heap
SECTION data_fcntl_stdio_heap_tail
__i_fcntl_heap_3: defw 0
ELSE
; terminate stdio heap
SECTION data_fcntl_stdio_heap_tail
__i_fcntl_heap_2: defw 0
ENDIF
ELSE
; no FDSTRUCTs statically created
IF __clib_stdio_heap_size > 14
SECTION data_clib
SECTION data_fcntl
PUBLIC __stdio_heap
__stdio_heap: defw __stdio_block
SECTION bss_clib
SECTION bss_fcntl
PUBLIC __stdio_block
__stdio_block: defs __clib_stdio_heap_size
SECTION code_crt_init
ld hl,__stdio_block
ld bc,__clib_stdio_heap_size
EXTERN asm_heap_init
call asm_heap_init
ENDIF
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; STARTUP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION CODE
PUBLIC __Start, __Exit
EXTERN _main
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; USER PREAMBLE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __crt_include_preamble
include "crt_preamble.asm"
SECTION CODE
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PAGE ZERO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF (ASMPC = 0) && (__crt_org_code = 0)
include "../crt_page_zero_z80.inc"
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CRT INIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
__Start:
include "../crt_start_di.inc"
IF (__crt_on_exit & 0x10000) && (__crt_on_exit & 0x20000) && (!(__crt_on_exit & 0x8)) && (__crt_on_exit & 0x2)
; returning to basic
push iy
exx
push hl
IF __crt_enable_commandline = 2
exx
ENDIF
ENDIF
include "../crt_save_sp.inc"
__Restart:
include "../crt_init_sp.inc"
; command line
IF (__crt_enable_commandline = 1) || (__crt_enable_commandline >= 3)
include "../crt_cmdline_empty.inc"
ENDIF
__Restart_2:
IF __crt_enable_commandline >= 1
push hl ; argv
push bc ; argc
ENDIF
; initialize data section
include "../clib_init_data.inc"
; initialize bss section
include "../clib_init_bss.inc"
; interrupt mode
include "../crt_set_interrupt_mode.inc"
SECTION code_crt_init ; user and library initialization
SECTION code_crt_main
include "../crt_start_ei.inc"
; call user program
call _main ; hl = return status
; run exit stack
IF __clib_exit_stack_size > 0
EXTERN asm_exit
jp asm_exit ; exit function jumps to __Exit
ENDIF
__Exit:
IF !((__crt_on_exit & 0x10000) && (__crt_on_exit & 0x8))
; not restarting
push hl ; save return status
ENDIF
SECTION code_crt_exit ; user and library cleanup
SECTION code_crt_return
; close files
include "../clib_close.inc"
; terminate
IF (__crt_on_exit & 0x10000) && (__crt_on_exit & 0x20000) && (!(__crt_on_exit & 0x8)) && (__crt_on_exit & 0x2)
; returning to basic
include "crt_exit_basic.inc"
ELSE
include "../crt_exit_eidi.inc"
include "../crt_restore_sp.inc"
include "../crt_program_exit.inc"
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; RUNTIME VARS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "../crt_jump_vectors_z80.inc"
IF (__crt_on_exit & 0x10000) && ((__crt_on_exit & 0x6) || ((__crt_on_exit & 0x8) && (__register_sp = -1)))
SECTION BSS_UNINITIALIZED
__sp_or_ret: defw 0
ENDIF
include "../clib_variables.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CLIB STUBS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "../clib_stubs.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; esxdos dot command ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; esxdos extended dot command ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; nextos extended dot command ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
mips-basic-algorithms/logical-and-arithmetic-operations/ex3.asm | jvwasquevite/computer-architecture-and-organization | 0 | 177061 | # Comecando com 'ori $t1, $zero, 0x01', escrever '0xFFFFFFFF' em $t1
# sll + or: permite aumentar o numero de uns (1) até ter 16
# Ao ter 16 uns (1), ao realizar o or, todos os 32 bits se tornam uns (1)
# Inicializa o $t1 = 00000000000000000000000000000001 (32 bits) = 1
ori $t1, $zero, 0x01
# Desloca o t1 1 bit a esquerda e salva em t2
# Concatena (soma) o t1 com o t2 e salva em t1
sll $t2, $t1, 1 # t2 = 00000000000000000000000000000010 = 2
or $t1, $t1, $t2 # t1 = 00000000000000000000000000000011 = 3
# Desloca o t1 2 bits a esquerda e salva em t2
# Concatena (soma) o t1 com o t2 e salva em t1
sll $t2, $t1, 2 # t2 = 00000000000000000000000000001100 = 12
or $t1, $t1, $t2 # t1 = 00000000000000000000000000001111 = 15
# Desloca o t1 4 bits a esquerda e salva em t2
# Concatena (soma) o t1 com o t2 e salva em t1
sll $t2, $t1, 4 # t2 = 00000000000000000000000011110000 = 240
or $t1, $t1, $t2 # t1 = 00000000000000000000000011111111 = 255
# Desloca o t1 8 bits a esquerda e salva em t2
# Concatena (soma) o t1 com o t2 e salva em t1
sll $t2, $t1, 8 # t2 = 00000000000000001111111100000000 = 65280
or $t1, $t1, $t2 # t1 = 00000000000000001111111111111111 = 65535
# Desloca o t1 16 bits a esquerda e salva em t2
# Concatena (soma) o t1 com o t2 e salva em t1
sll $t2, $t1, 16 # t2 = 11111111111111110000000000000000 = 4294901760
or $t1, $t1, $t2 # t1 = 11111111111111111111111111111111 = 4294967295 |
oeis/142/A142919.asm | neoneye/loda-programs | 11 | 28680 | ; A142919: Primes congruent to 53 mod 63.
; Submitted by <NAME>(w3)
; 53,179,431,557,683,809,1061,1187,1439,2069,2447,2699,3203,3329,3581,3833,4211,4337,4463,4967,5471,5849,6101,6353,6857,6983,7109,7487,8117,8243,8369,8747,8999,9377,9629,10007,10133,10259,10889,11393,11519,11897,12149,12401,12527,12653,13913,14543,14669,15173,15299,15551,15803,16433,16811,16937,17189,18701,19079,19457,19583,19709,19961,20717,21221,21347,21599,21851,21977,22229,22481,22859,23741,23993,24371,24623,24749,25127,25253,26261,26387,26513,26891,27017,27143,27647,27773,28151,28277,28403
mov $1,26
mov $2,$0
add $2,2
pow $2,2
lpb $2
sub $2,1
mov $3,$1
mul $3,2
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,63
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
lpe
mov $0,$1
mul $0,2
sub $0,125
|
nop.g4 | lutherwenxu/nopc-go | 0 | 5879 | grammar nop;
nop_file: compiler_pragma* importStatement? (let | constant | function | structDecl | impl | trait)+;
compiler_pragma: PRAGMA;
importStatement
: IMPORT LPAREN (IDENTIFIER COMMA)* IDENTIFIER RPAREN
| IMPORT IDENTIFIER
;
let
: LET letVariableDefinition typeIdentifier? EQUAL statement
| LET LPAREN (letVariableDefinition typeIdentifier? COMMA)+ letVariableDefinition typeIdentifier? RPAREN EQUAL statement
;
letVariableDefinition: PUB? MUT? STATIC? IDENTIFIER;
constant
: CONST PUB? IDENTIFIER EQUAL statement
| CONST LPAREN (PUB? IDENTIFIER COMMA)+ PUB? IDENTIFIER RPAREN EQUAL statement
;
functionHeader: FN IDENTIFIER LPAREN ((functionParameter COMMA)* functionParameter)? RPAREN constantType?;
function: functionHeader LCURLY operation* RCURLY;
functionParameter
: (IDENTIFIER COMMA)* IDENTIFIER typeIdentifier //x, y, z i32
| STAR MUT? SELF
;
operation
: let
| returnStatement
| ifStatement
| matchStatement
| assign
| statement
;
assign: statement (PLUS | MINUS | STAR | SLASH | PERCENT)? EQUAL statement;
returnStatement: RETURN statement;
ifStatement: IF statement LCURLY operation* RCURLY elseStatement?;
elseStatement: ELSE LCURLY operation* RCURLY;
matchStatement: MATCH statement LCURLY matchCandidate+ RCURLY;
matchCandidate: statement RARROW ((LCURLY operation* RCURLY) | operation);
statement
: LPAREN statement RPAREN
| literal
| IDENTIFIER
| STAR statement
| SELF
| statement (DOT | RARROW) statement
| statement LPAREN functionParameters RPAREN
| statement EQUAL EQUAL statement
| statement EXCLAMATION EQUAL statement
| statement LESSERTHAN (EQUAL)? statement
| statement GREATERTHAN (EQUAL)? statement
| statement (STAR | SLASH | PERCENT) statement
| statement (PLUS | MINUS) statement
| statement LBRACKET statement RBRACKET
| arrayInitializer
| objectInitializer
;
functionParameters: (statement (COMMA statement)*)?;
literal
: STRING
| FLOAT
| NUMBER
| TRUE
| FALSE
;
arrayInitializer
: LBRACKET NUMBER RBRACKET typeIdentifier
| LBRACKET NUMBER? RBRACKET typeIdentifier LCURLY (statement COMMA)* statement RCURLY
;
objectInitializer: constantType LCURLY ((statement COMMA)* statement)? RCURLY;
structDecl: PUB? STRUCT IDENTIFIER LCURLY (structVar COMMA)* structVar RCURLY;
structVar: PUB? (IDENTIFIER COMMA)* IDENTIFIER typeIdentifier;
impl: IMPL IDENTIFIER (FOR typeIdentifier)? LCURLY function* RCURLY;
trait: TRAIT IDENTIFIER LCURLY functionHeader* functionHeader RCURLY;
typeIdentifier
: MUT constantType
| constantType
;
constantType
: STAR typeIdentifier
| LBRACKET RBRACKET typeIdentifier
| IDENTIFIER (LESSERTHAN typeIdentifier GREATERTHAN)?
;
/** LEXER LOGIC */
ONELINECOMMENT: '//' .*? [\r\n] -> skip;
MULTILINECOMMENT: '/*' .*? '*/' -> skip;
STRING: ('"' (.*? ~[\\])+? '"') | ('\'' (.*? ~[\\])+? '\'');
PRAGMA: '#' ~[\r\n]*;
IMPORT: 'import';
IMPL: 'impl';
TRAIT: 'trait';
LET: 'let';
CONST: 'const';
PUB: 'pub';
MUT: 'mut';
STATIC: 'static';
FN: 'fn';
RETURN: 'return';
IF: 'if';
ELSE: 'else';
MATCH: 'match';
TRUE: 'true';
FALSE: 'false';
STRUCT: 'struct';
FOR: 'for';
SELF: 'self';
COMMA: ',';
LPAREN: '(';
RPAREN: ')';
LCURLY: '{';
RCURLY: '}';
LBRACKET: '[';
RBRACKET: ']';
EQUAL: '=';
DOT: '.';
RARROW: '->';
PLUS: '+';
MINUS: '-';
STAR: '*';
SLASH: '/';
PERCENT: '%';
EXCLAMATION: '!';
LESSERTHAN: '<';
GREATERTHAN: '>';
IDENTIFIER: [A-Za-z][A-Za-z0-9]*;
ALPHA: [A-Za-z];
NUMBER: [0-9]+;
FLOAT: NUMBER DOT NUMBER;
DIGIT: [0-9];
WHITESPACE: [ \t\r\n]+ -> skip; //Whitespace doesn't hold any meaning in our syntax
|
oeis/162/A162557.asm | neoneye/loda-programs | 11 | 176977 | ; A162557: a(n) = ((3+sqrt(3))*(4+sqrt(3))^n+(3-sqrt(3))*(4-sqrt(3))^n)/6.
; Submitted by <NAME>
; 1,5,27,151,857,4893,28003,160415,919281,5268853,30200171,173106279,992248009,5687602445,32601595443,186873931759,1071170713313,6140004593637,35194817476027,201738480090935,1156375213539129,6628401467130877,37994333961038339,217785452615605311,1248357279431344081,7155647351447883605,41016534178975595787,235108857862982279431,1347655918577175490217,7724832196398634289133,44279130629685792940243,253810226484304097763215,1454853113688517473882561,8339291965212186520138693,47801245243746765000636251
mov $1,1
mov $3,1
lpb $0
sub $0,1
mov $2,$3
mul $2,3
mul $3,4
add $3,$1
mul $1,4
add $1,$2
lpe
mov $0,$3
|
src/main/antlr/ES6.g4 | luisvt/js2dart | 6 | 2353 | grammar ES6;
//SourceCharacter ::
// any Unicode code point
//InputElementDiv ::
// WhiteSpace
// LineTerminator
// Comment
// CommonToken
// DivPunctuator
// RightBracePunctuator
inputElementDiv
: WhiteSpace
| LineTerminator
| Comment
| commonToken
| DivPunctuator
| RightBracePunctuator
;
// InputElementRegExp ::
// WhiteSpace
// LineTerminator
// Comment
// CommonToken
// RightBracePunctuator
// RegularExpressionLiteral
inputElementRegExp
: WhiteSpace
| LineTerminator
| Comment
| commonToken
| RightBracePunctuator
| RegularExpressionLiteral
;
// InputElementRegExpOrTemplateTail ::
// WhiteSpace
// LineTerminator
// Comment
// CommonToken
// RegularExpressionLiteral
// TemplateSubstitutionTail
inputElementRegExpOrTemplateTail
: WhiteSpace
| LineTerminator
| Comment
| commonToken
| RegularExpressionLiteral
| templateSubstitutionTail
;
// InputElementTemplateTail ::
// WhiteSpace
// LineTerminator
// Comment
// CommonToken
// DivPunctuator
// TemplateSubstitutionTail
inputElementTemplateTail
: WhiteSpace
| LineTerminator
| Comment
| commonToken
| DivPunctuator
| templateSubstitutionTail
;
// WhiteSpace ::
// <TAB>
// <VT>
// <FF>
// <SP>
// <NBSP>
// <ZWNBSP>
// <USP>
WhiteSpace
: [\t\u000B\u000C\u0020\u00A0]
;
WhiteSpaces
: [\t\u000B\u000C\u0020\u00A0]+ -> channel(HIDDEN)
;
// LineTerminator ::
// <LF>
// <CR>
// <LS>
// <PS>
LineTerminator
: [\r\n\u2028\u2029]
;
// LineTerminatorSequence ::
// <LF>
// <CR> [lookahead ≠ <LF>]
// <LS>
// <PS>
// <CR> <LF>
LineTerminatorSequence
: '\r\n'
| LineTerminator
;
// Comment ::
// MultiLineComment
// SingleLineComment
Comment
: MultiLineComment
| SingleLineComment
;
// MultiLineComment ::
// /* MultiLineCommentCharsopt */
MultiLineComment
: '/*' MultiLineCommentChars? '*/'
;
// MultiLineCommentChars ::
// MultiLineNotAsteriskChar MultiLineCommentCharsopt
// * PostAsteriskCommentCharsopt
MultiLineCommentChars
: MultiLineNotAsteriskChar MultiLineCommentChars?
| '*' PostAsteriskCommentChars?
;
// PostAsteriskCommentChars ::
// MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentCharsopt
// * PostAsteriskCommentCharsopt
PostAsteriskCommentChars
: MultiLineNotForwardSlashOrAsteriskChar MultiLineCommentChars?
| '*' PostAsteriskCommentChars?
;
// MultiLineNotAsteriskChar ::
// SourceCharacter but not *
MultiLineNotAsteriskChar
: ~[*]
;
// MultiLineNotForwardSlashOrAsteriskChar ::
// SourceCharacter but not one of / or *
MultiLineNotForwardSlashOrAsteriskChar
: ~[/*]
;
// SingleLineComment ::
// // SingleLineCommentCharsopt
SingleLineComment
: '//' SingleLineCommentChars?
;
// SingleLineCommentChars ::
// SingleLineCommentChar SingleLineCommentCharsopt
SingleLineCommentChars
: SingleLineCommentChar SingleLineCommentChars?
;
// SingleLineCommentChar ::
// SourceCharacter but not LineTerminator
SingleLineCommentChar
: ~[\r\n\u2028\u2029]
;
// CommonToken ::
// IdentifierName
// Punctuator
// NumericLiteral
// StringLiteral
// Template
commonToken
: IdentifierName
| Punctuator
| NumericLiteral
| StringLiteral
| template
;
// IdentifierName ::
// IdentifierStart
// IdentifierName IdentifierPart
IdentifierName
: IdentifierStart IdentifierPart*
;
// IdentifierStart ::
// UnicodeIDStart
// $
// _
// \ UnicodeEscapeSequence
IdentifierStart
: UnicodeIDStart
| '$'
| '_'
| '\\' UnicodeEscapeSequence
;
// IdentifierPart ::
// UnicodeIDContinue
// $
// _
// \ UnicodeEscapeSequence
// <ZWNJ>
// <ZWJ>
IdentifierPart
: UnicodeIDContinue
| '$'
| '_'
| '\\' UnicodeEscapeSequence
| ZWNJ
| ZWJ
;
fragment ZWNJ
: '\u200C'
;
fragment ZWJ
: '\u200D'
;
// UnicodeIDStart ::
// any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
UnicodeIDStart
: //any Unicode code point with the Unicode property "ID_Start" or "Other_ID_Start"
;
// UnicodeIDContinue ::
// any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
UnicodeIDContinue
: //any Unicode code point with the Unicode property "ID_Continue" or "Other_ID_Continue", or "Other_ID_Start"
;
// ReservedWord ::
// Keyword
// FutureReservedWord
// NullLiteral
// BooleanLiteral
ReservedWord
: Keyword
| FutureReservedWord
| NullLiteral
| BooleanLiteral
;
// Keyword :: one of
//
// break do in typeof case
// else instanceof var catch export
// new void class extends return
// while const finally super with
// continue for switch yield debugger
// function this default if throw
// delete import try
Keyword
: 'break' | 'do' | 'in' | 'typeof' | 'case'
| 'else' | 'instanceof' | 'var' | 'catch' | 'export'
| 'new' | 'void' | 'class' | 'extends' | 'return'
| 'while' | 'const' | 'finally' | 'super' | 'with'
| 'continue' | 'for' | 'switch' | 'yield' | 'debugger'
| 'function' | 'this' | 'default' | 'if' | 'throw'
| 'delete' | 'import' | 'try'
;
// FutureReservedWord :: one of
// enum await implements package protected
// interface private public
FutureReservedWord
: 'enum' | 'await' | 'implements' | 'package' | 'protected'
| 'interface' | 'private' | 'public'
;
// Punctuator :: one of
// { } ( ) [ ] . ; , <
// > <= >= == != === !== + - *
// % ++ -- << >> >>> & | ^ !
// ~ && || ? :: = += -= *= %=
// <<= >>= >>>= &= |= ^= =>
Punctuator
: '{' | '}' | '(' | ')' | '[' | ']' | '.' | ';' | ',' | '<'
| '>' | '<=' | '>=' | '==' | '!=' | '===' | '!==' | '+' | '-' | '*'
| '%' | '++' | '--' | '<<' | '>>' | '>>>' | '&' | '|' | '^' | '!'
| '~' | '&&' | '||' | '?' | '::' | '=' | '+=' | '-=' | '*=' | '%='
| '<<=' | '>>=' | '>>>=' | '&=' | '|=' | '^=' | '=>'
;
// DivPunctuator :: one of
// / /=
DivPunctuator
: '/' | '/='
;
// RightBracePunctuator :: one of
// )
RightBracePunctuator
: ')'
;
// NullLiteral ::
// null
NullLiteral
: 'null'
;
// BooleanLiteral ::
// true
// false
BooleanLiteral
: 'true'
| 'false'
;
// NumericLiteral ::
// DecimalLiteral
// BinaryIntegerLiteral
// OctalIntegerLiteral
// HexIntegerLiteral
NumericLiteral
: DecimalLiteral
| BinaryIntegerLiteral
| OctalIntegerLiteral
| HexIntegerLiteral
;
// DecimalLiteral ::
// DecimalIntegerLiteral . DecimalDigitsopt ExponentPartopt
// . DecimalDigits ExponentPartopt
// DecimalIntegerLiteral ExponentPartopt
DecimalLiteral
: DecimalIntegerLiteral '.' DecimalDigits? ExponentPart?
| '.' DecimalDigits ExponentPart?
| DecimalIntegerLiteral ExponentPart?
;
// DecimalIntegerLiteral ::
// 0
// NonZeroDigit DecimalDigitsopt
DecimalIntegerLiteral
: '0'
| NonZeroDigit DecimalDigits?
;
// DecimalDigits ::
// DecimalDigit
// DecimalDigits DecimalDigit
DecimalDigits
: DecimalDigit+
// | DecimalDigits DecimalDigit
;
// DecimalDigit :: one of
// 0 1 2 3 4 5 6 7 8 9
DecimalDigit
: [0-9]
;
// NonZeroDigit :: one of
// 1 2 3 4 5 6 7 8 9
NonZeroDigit
: [1-9]
;
// ExponentPart ::
// ExponentIndicator SignedInteger
ExponentPart
: ExponentIndicator SignedInteger
;
// ExponentIndicator :: one of
// e E
ExponentIndicator
: 'e' | 'E'
;
// SignedInteger ::
// DecimalDigits
// + DecimalDigits
// - DecimalDigits
SignedInteger
: DecimalDigits
| '+' DecimalDigits
| '-' DecimalDigits
;
// BinaryIntegerLiteral ::
// 0b BinaryDigits
// 0B BinaryDigits
// BinaryDigits ::
// BinaryDigit
// BinaryDigits BinaryDigit
BinaryIntegerLiteral
: '0' [bB] BinaryDigit+
;
// BinaryDigit :: one of
// 0 1
BinaryDigit
: '0' | '1'
;
// OctalIntegerLiteral ::
// 0o OctalDigits
// 0O OctalDigits
// OctalDigits ::
// OctalDigit
// OctalDigits OctalDigit
OctalIntegerLiteral
: '0' [oO] OctalDigit+
;
// OctalDigit :: one of
// 0 1 2 3 4 5 6 7
OctalDigit
: [0-7]
;
// HexIntegerLiteral ::
// 0x HexDigits
// 0X HexDigits
//
// HexDigits ::
// HexDigit
// HexDigits HexDigit
HexIntegerLiteral
: '0' [xX] HexDigit+;
// HexDigit :: one of
// 0 1 2 3 4 5 6 7 8 9
// a b c d e f A B C D
// E F
HexDigit
: [0-9a-fA-F]
;
// StringLiteral ::
// " DoubleStringCharactersopt "
// ' SingleStringCharactersopt '
StringLiteral
: '"' DoubleStringCharacters? '"'
| '\'' SingleStringCharacters? '\''
;
// DoubleStringCharacters ::
// DoubleStringCharacter DoubleStringCharactersopt
DoubleStringCharacters
: DoubleStringCharacter DoubleStringCharacters?
;
// SingleStringCharacters ::
// SingleStringCharacter SingleStringCharactersopt
SingleStringCharacters
: SingleStringCharacter SingleStringCharacters?
;
// DoubleStringCharacter ::
// SourceCharacter but not one of " or \ or LineTerminator
// \ EscapeSequence
// LineContinuation
DoubleStringCharacter
: ~('"' | '\\' | LineTerminator)
| '\\' EscapeSequence
| LineContinuation
;
// SingleStringCharacter ::
// SourceCharacter but not one of ' or \ or LineTerminator
// \ EscapeSequence
// LineContinuation
SingleStringCharacter
: ~('\'' | '\\' | LineTerminator)
| '\\' EscapeSequence
| LineContinuation
;
// LineContinuation ::
// \ LineTerminatorSequence
LineContinuation
: '\\' LineTerminatorSequence
;
// EscapeSequence ::
// CharacterEscapeSequence
// 0 [lookahead ≠ DecimalDigit]
// HexEscapeSequence
// UnicodeEscapeSequence
EscapeSequence
: CharacterEscapeSequence
| '0' {_input.LA(1) != DecimalDigit}?
| HexEscapeSequence
| UnicodeEscapeSequence
;
// CharacterEscapeSequence ::
// SingleEscapeCharacter
// NonEscapeCharacter
CharacterEscapeSequence
: SingleEscapeCharacter
| NonEscapeCharacter
;
// SingleEscapeCharacter :: one of
// ' " \ b f n r t v
SingleEscapeCharacter
: '\'' | '"' | '\\' | 'b' | 'f' | 'n' | 'r' | 't' | 'v'
;
// NonEscapeCharacter ::
// SourceCharacter but not one of EscapeCharacter or LineTerminator
NonEscapeCharacter
: ~(EscapeCharacter | LineTerminator)
;
// EscapeCharacter ::
// SingleEscapeCharacter
// DecimalDigit
// x
// u
EscapeCharacter
: SingleEscapeCharacter
| DecimalDigit
| 'x'
| 'u'
;
// HexEscapeSequence ::
// x HexDigit HexDigit
HexEscapeSequence
: 'x' HexDigit HexDigit
;
// UnicodeEscapeSequence ::
// u Hex4Digits
// u{ HexDigits }
UnicodeEscapeSequence
: 'u' Hex4Digits
| 'u{' HexDigit+ '}'
;
// Hex4Digits ::
// HexDigit HexDigit HexDigit HexDigit
Hex4Digits
: HexDigit HexDigit HexDigit HexDigit
;
// RegularExpressionLiteral ::
// / RegularExpressionBody / RegularExpressionFlags
RegularExpressionLiteral
: '/' RegularExpressionBody '/' RegularExpressionFlags
;
// RegularExpressionBody ::
// RegularExpressionFirstChar RegularExpressionChars
RegularExpressionBody
: RegularExpressionFirstChar RegularExpressionChars
;
// RegularExpressionChars ::
// [empty]
// RegularExpressionChars RegularExpressionChar
RegularExpressionChars
: RegularExpressionChar*
;
// RegularExpressionFirstChar ::
// RegularExpressionNonTerminator but not one of * or \ or / or [
// RegularExpressionBackslashSequence
// RegularExpressionClass
RegularExpressionFirstChar
: RegularExpressionNonTerminator ~('*' | '\\' | '/' | '[')
| RegularExpressionBackslashSequence
| RegularExpressionClass
;
// RegularExpressionChar ::
// RegularExpressionNonTerminator but not one of \ or / or [
// RegularExpressionBackslashSequence
// RegularExpressionClass
RegularExpressionChar
: RegularExpressionNonTerminator ~('\\' | '/' | '[')
| RegularExpressionBackslashSequence
| RegularExpressionClass
;
// RegularExpressionBackslashSequence ::
// \ RegularExpressionNonTerminator
RegularExpressionBackslashSequence
: '\\' RegularExpressionNonTerminator
;
// RegularExpressionNonTerminator ::
// SourceCharacter but not LineTerminator
RegularExpressionNonTerminator
: ~LineTerminator
;
// RegularExpressionClass ::
// [ RegularExpressionClassChars ]
RegularExpressionClass
: '[' RegularExpressionClassChars ']'
;
// RegularExpressionClassChars ::
// [empty]
// RegularExpressionClassChars RegularExpressionClassChar
RegularExpressionClassChars
: RegularExpressionClassChar*
;
// RegularExpressionClassChar ::
// RegularExpressionNonTerminator but not one of ] or \
// RegularExpressionBackslashSequence
RegularExpressionClassChar
: RegularExpressionNonTerminator ~(']' | '\\')
| RegularExpressionBackslashSequence
;
// RegularExpressionFlags ::
// [empty]
// RegularExpressionFlags IdentifierPart
RegularExpressionFlags
: IdentifierPart*
;
// Template ::
// NoSubstitutionTemplate
// TemplateHead
template
: noSubstitutionTemplate
| templateHead
;
// NoSubstitutionTemplate ::
// ` TemplateCharactersopt `
noSubstitutionTemplate
: '`' templateCharacters? '`'
;
// TemplateHead ::
// ` TemplateCharactersopt ${
templateHead
: '`' templateCharacters? '${'
;
// TemplateSubstitutionTail ::
// TemplateMiddle
// TemplateTail
templateSubstitutionTail
: templateMiddle
| templateTail
;
// TemplateMiddle ::
// } TemplateCharactersopt ${
templateMiddle
: '}' templateCharacters? '${'
;
// TemplateTail ::
// } TemplateCharactersopt `
templateTail
: '}' templateCharacters? '`'
;
// TemplateCharacters ::
// TemplateCharacter TemplateCharactersopt
templateCharacters
: templateCharacter templateCharacters?
;
// TemplateCharacter ::
// $ [lookahead ≠ {]
// \ EscapeSequence
// LineContinuation
// LineTerminatorSequence
// SourceCharacter but not one of ` or \ or $ or LineTerminator
templateCharacter
: '$' {(_input.LA(1) != '{')}?
| '\\' EscapeSequence
| LineContinuation
| LineTerminatorSequence
| ~('`' | '\\' | '$' | LineTerminator)
;
// IdentifierReference[Yield] :
// Identifier
// [~Yield] yield
identifierReference
: identifier
| 'yield'
;
identifierReference_Yield
: identifier
;
// BindingIdentifier[Yield] :
// Identifier
// [~Yield] yield
bindingIdentifier
: identifier
| 'yield'
;
bindingIdentifier_Yield
: identifier
;
// LabelIdentifier[Yield] :
// Identifier
// [~Yield] yield
labelIdentifier
: identifier
| 'yield'
;
labelIdentifier_Yield
: identifier
;
// Identifier :
// IdentifierName but not ReservedWord
identifier
: IdentifierName ~ReservedWord
;
// PrimaryExpression[Yield] :
// this
// IdentifierReference[?Yield]
// Literal
// ArrayLiteral[?Yield]
// ObjectLiteral[?Yield]
// FunctionExpression
// ClassExpression[?Yield]
// GeneratorExpression
// RegularExpressionLiteral
// TemplateLiteral[?Yield]
// CoverParenthesizedExpressionAndArrowParameterList[?Yield]
primaryExpression
: 'this'
| identifierReference
| Literal
| arrayLiteral
| objectLiteral
| functionExpression
| classExpression
| generatorExpression
| RegularExpressionLiteral
| templateLiteral
| coverParenthesizedExpressionAndArrowParameterList
;
primaryExpression_Yield
: 'this'
| identifierReference_Yield
| Literal
| arrayLiteral_Yield
| objectLiteral_Yield
| functionExpression
| classExpression_Yield
| generatorExpression
| RegularExpressionLiteral
| templateLiteral_Yield
| coverParenthesizedExpressionAndArrowParameterList_Yield
;
// CoverParenthesizedExpressionAndArrowParameterList[Yield] :
// ( Expression[In, ?Yield] )
// ( )
// ( ... BindingIdentifier[?Yield] )
// ( Expression[In, ?Yield] , ... BindingIdentifier[?Yield] )
coverParenthesizedExpressionAndArrowParameterList
: '(' expression_In ')'
| '(' ')'
| '(' '...' bindingIdentifier ')'
| '(' expression_In ',' '...' bindingIdentifier ')'
;
coverParenthesizedExpressionAndArrowParameterList_Yield
: '(' expression_In_Yield ')'
| '(' ')'
| '(' '...' bindingIdentifier_Yield ')'
| '(' expression_In_Yield ',' '...' bindingIdentifier_Yield ')'
;
// Literal :
// NullLiteral
// BooleanLiteral
// NumericLiteral
// StringLiteral
Literal
: NullLiteral
| BooleanLiteral
| NumericLiteral
| StringLiteral
;
// ArrayLiteral[Yield] :
// [ Elisionopt ]
// [ ElementList[?Yield] ]
// [ ElementList[?Yield] , Elisionopt ]
arrayLiteral
: '[' Elision? ']'
| '[' elementList ']'
| '[' elementList ',' Elision? ']'
;
arrayLiteral_Yield
: '[' Elision? ']'
| '[' elementList_Yield ']'
| '[' elementList_Yield ',' Elision? ']'
;
// ElementList[Yield] :
// Elisionopt AssignmentExpression[In, ?Yield]
// Elisionopt SpreadElement[?Yield]
// ElementList[?Yield] , Elisionopt AssignmentExpression[In, ?Yield]
// ElementList[?Yield] , Elisionopt SpreadElement[?Yield]
elementList
: Elision? (assignmentExpression_In | spreadElement) (',' Elision? (assignmentExpression_In | spreadElement))*
;
elementList_Yield
: Elision? (assignmentExpression_In_Yield | spreadElement_Yield) (',' Elision? (assignmentExpression_In_Yield | spreadElement_Yield))*
;
// Elision :
// ,
// Elision ,
Elision
: ','+
;
// SpreadElement[Yield] :
// ... AssignmentExpression[In, ?Yield]
spreadElement
: '...' assignmentExpression_In
;
spreadElement_Yield
: '...' assignmentExpression_In_Yield
;
// ObjectLiteral[Yield] :
// { }
// { PropertyDefinitionList[?Yield] }
// { PropertyDefinitionList[?Yield] , }
objectLiteral
: '{' '}'
| '{' propertyDefinitionList '}'
| '{' propertyDefinitionList ',' '}'
;
objectLiteral_Yield
: '{' '}'
| '{' propertyDefinitionList_Yield '}'
| '{' propertyDefinitionList_Yield ',' '}'
;
// PropertyDefinitionList[Yield] :
// PropertyDefinition[?Yield]
// PropertyDefinitionList[?Yield] , PropertyDefinition[?Yield]
propertyDefinitionList
: propertyDefinition (',' propertyDefinition)*
;
propertyDefinitionList_Yield
: propertyDefinition_Yield (',' propertyDefinition_Yield)*
;
// PropertyDefinition[Yield] :
// IdentifierReference[?Yield]
// CoverInitializedName[?Yield]
// PropertyName[?Yield] : AssignmentExpression[In, ?Yield]
// MethodDefinition[?Yield]
propertyDefinition
: identifierReference
| coverInitializedName
| propertyName ':' assignmentExpression_In
| methodDefinition
;
propertyDefinition_Yield
: identifierReference_Yield
| coverInitializedName_Yield
| propertyName_Yield ':' assignmentExpression_In_Yield
| methodDefinition_Yield
;
// PropertyName[Yield] :
// LiteralPropertyName
// ComputedPropertyName[?Yield]
propertyName
: LiteralPropertyName
| computedPropertyName
;
propertyName_Yield
: LiteralPropertyName
| computedPropertyName_Yield
;
// LiteralPropertyName :
// IdentifierName
// StringLiteral
// NumericLiteral
LiteralPropertyName
: IdentifierName
| StringLiteral
| NumericLiteral
;
// ComputedPropertyName[Yield] :
// [ AssignmentExpression[In, ?Yield] ]
computedPropertyName
: '[' assignmentExpression_In ']'
;
computedPropertyName_Yield
: '[' assignmentExpression_In_Yield ']'
;
// CoverInitializedName[Yield] :
// IdentifierReference[?Yield] Initializer[In, ?Yield]
coverInitializedName
: identifierReference initializer_In
;
coverInitializedName_Yield
: identifierReference_Yield initializer_In_Yield
;
// Initializer[In, Yield] :
// = AssignmentExpression[?In, ?Yield]
initializer
: '=' assignmentExpression
;
initializer_In
: '=' assignmentExpression_In
;
initializer_Yield
: '=' assignmentExpression_Yield
;
initializer_In_Yield
: '=' assignmentExpression_In_Yield
;
// TemplateLiteral[Yield] :
// NoSubstitutionTemplate
// TemplateHead Expression[In, ?Yield] TemplateSpans[?Yield]
templateLiteral
: noSubstitutionTemplate
| templateHead expression_In templateSpans
;
templateLiteral_Yield
: noSubstitutionTemplate
| templateHead expression_In_Yield templateSpans_Yield
;
// TemplateSpans[Yield] :
// TemplateTail
// TemplateMiddleList[?Yield] TemplateTail
templateSpans
: templateTail
| templateMiddleList templateTail
;
templateSpans_Yield
: templateTail
| templateMiddleList_Yield templateTail
;
// TemplateMiddleList[Yield] :
// TemplateMiddle Expression[In, ?Yield]
// TemplateMiddleList[?Yield] TemplateMiddle Expression[In, ?Yield]
templateMiddleList
: (templateMiddle expression_In)+
;
templateMiddleList_Yield
: (templateMiddle expression_In_Yield)+
;
// MemberExpression[Yield] :
// PrimaryExpression[?Yield]
// MemberExpression[?Yield] [ Expression[In, ?Yield] ]
// MemberExpression[?Yield] . IdentifierName
// MemberExpression[?Yield] TemplateLiteral[?Yield]
// SuperProperty[?Yield]
// MetaProperty
// new MemberExpression[?Yield] Arguments[?Yield]
memberExpression
: primaryExpression
| memberExpression '[' expression_In ']'
| memberExpression '.' IdentifierName
| memberExpression templateLiteral
| superProperty
| MetaProperty
| 'new' memberExpression arguments
;
memberExpression_Yield
: primaryExpression_Yield
| memberExpression_Yield '[' expression_In_Yield ']'
| memberExpression_Yield '.' IdentifierName
| memberExpression_Yield templateLiteral_Yield
| superProperty_Yield
| MetaProperty
| 'new' memberExpression_Yield arguments_Yield
;
// SuperProperty[Yield] :
// super [ Expression[In, ?Yield] ]
// super . IdentifierName
superProperty
: 'super' '[' expression_In ']'
| 'super' '.' IdentifierName
;
superProperty_Yield
: 'super' '[' expression_In_Yield ']'
| 'super' '.' IdentifierName
;
// MetaProperty :
// NewTarget
MetaProperty
: NewTarget
;
// NewTarget :
// new . target
NewTarget
: 'new' '.' 'target'
;
// NewExpression[Yield] :
// MemberExpression[?Yield]
// new NewExpression[?Yield]
newExpression
: memberExpression
| 'new' newExpression
;
newExpression_Yield
: memberExpression_Yield
| 'new' newExpression_Yield
;
// CallExpression[Yield] :
// MemberExpression[?Yield] Arguments[?Yield]
// SuperCall[?Yield]
// CallExpression[?Yield] Arguments[?Yield]
// CallExpression[?Yield] [ Expression[In, ?Yield] ]
// CallExpression[?Yield] . IdentifierName
// CallExpression[?Yield] TemplateLiteral[?Yield]
callExpression
: memberExpression arguments
| superCall
| callExpression arguments
| callExpression '[' expression_In ']'
| callExpression '.' IdentifierName
| callExpression templateLiteral
;
callExpression_Yield
: memberExpression_Yield arguments_Yield
| superCall_Yield
| callExpression_Yield arguments_Yield
| callExpression_Yield '[' expression_In_Yield ']'
| callExpression_Yield '.' IdentifierName
| callExpression_Yield templateLiteral_Yield
;
// SuperCall[Yield] :
// super Arguments[?Yield]
superCall
: 'super' arguments
;
superCall_Yield
: 'super' arguments_Yield
;
// Arguments[Yield] :
// ( )
// ( ArgumentList[?Yield] )
arguments
: '(' ')'
| '(' argumentList ')'
;
arguments_Yield
: '(' ')'
| '(' argumentList_Yield ')'
;
// ArgumentList[Yield] :
// AssignmentExpression[In, ?Yield]
// ... AssignmentExpression[In, ?Yield]
// ArgumentList[?Yield] , AssignmentExpression[In, ?Yield]
// ArgumentList[?Yield] , ... AssignmentExpression[In, ?Yield]
argumentList
: '...'? assignmentExpression_In (',' '...'? assignmentExpression_In)*
;
argumentList_Yield
: '...'? assignmentExpression_In_Yield (',' '...'? assignmentExpression_In_Yield)*
;
// LeftHandSideExpression[Yield] :
// NewExpression[?Yield]
// CallExpression[?Yield]
leftHandSideExpression
: newExpression
| callExpression
;
leftHandSideExpression_Yield
: newExpression_Yield
| callExpression_Yield
;
// PostfixExpression[Yield] :
// LeftHandSideExpression[?Yield]
// LeftHandSideExpression[?Yield] [no LineTerminator here] ++
// LeftHandSideExpression[?Yield] [no LineTerminator here] --
postfixExpression
: leftHandSideExpression
| leftHandSideExpression ~LineTerminator '++'
| leftHandSideExpression ~LineTerminator '--'
;
postfixExpression_Yield
: leftHandSideExpression_Yield
| leftHandSideExpression_Yield ~LineTerminator '++'
| leftHandSideExpression_Yield ~LineTerminator '--'
;
// UnaryExpression[Yield] :
// PostfixExpression[?Yield]
// delete UnaryExpression[?Yield]
// void UnaryExpression[?Yield]
// typeof UnaryExpression[?Yield]
// ++ UnaryExpression[?Yield]
// -- UnaryExpression[?Yield]
// + UnaryExpression[?Yield]
// - UnaryExpression[?Yield]
// ~ UnaryExpression[?Yield]
// ! UnaryExpression[?Yield]
unaryExpression
: postfixExpression
| 'delete' unaryExpression
| 'void' unaryExpression
| 'typeof' unaryExpression
| '++' unaryExpression
| '--' unaryExpression
| '+' unaryExpression
| '-' unaryExpression
| '~' unaryExpression
| '!' unaryExpression
;
unaryExpression_Yield
: postfixExpression_Yield
| 'delete' unaryExpression_Yield
| 'void' unaryExpression_Yield
| 'typeof' unaryExpression_Yield
| '++' unaryExpression_Yield
| '--' unaryExpression_Yield
| '+' unaryExpression_Yield
| '-' unaryExpression_Yield
| '~' unaryExpression_Yield
| '!' unaryExpression_Yield
;
// MultiplicativeExpression[Yield] :
// UnaryExpression[?Yield]
// MultiplicativeExpression[?Yield] MultiplicativeOperator UnaryExpression[?Yield]
multiplicativeExpression
: unaryExpression
| multiplicativeExpression MultiplicativeOperator unaryExpression
;
multiplicativeExpression_Yield
: unaryExpression_Yield
| multiplicativeExpression_Yield MultiplicativeOperator unaryExpression_Yield
;
// MultiplicativeOperator : one of
// * / %
MultiplicativeOperator
: '*' | '/' | '%'
;
// AdditiveExpression[Yield] :
// MultiplicativeExpression[?Yield]
// AdditiveExpression[?Yield] + MultiplicativeExpression[?Yield]
// AdditiveExpression[?Yield] - MultiplicativeExpression[?Yield]
additiveExpression
: multiplicativeExpression
| additiveExpression '+' multiplicativeExpression
| additiveExpression '-' multiplicativeExpression
;
additiveExpression_Yield
: multiplicativeExpression_Yield
| additiveExpression_Yield '+' multiplicativeExpression_Yield
| additiveExpression_Yield '-' multiplicativeExpression_Yield
;
// ShiftExpression[Yield] :
// AdditiveExpression[?Yield]
// ShiftExpression[?Yield] << AdditiveExpression[?Yield]
// ShiftExpression[?Yield] >> AdditiveExpression[?Yield]
// ShiftExpression[?Yield] >>> AdditiveExpression[?Yield]
shiftExpression
: additiveExpression
| shiftExpression '<<' additiveExpression
| shiftExpression '>>' additiveExpression
| shiftExpression '>>>' additiveExpression
;
shiftExpression_Yield
: additiveExpression_Yield
| shiftExpression_Yield '<<' additiveExpression_Yield
| shiftExpression_Yield '>>' additiveExpression_Yield
| shiftExpression_Yield '>>>' additiveExpression_Yield
;
// RelationalExpression[In, Yield] :
// ShiftExpression[?Yield]
// RelationalExpression[?In, ?Yield] < ShiftExpression[?Yield]
// RelationalExpression[?In, ?Yield] > ShiftExpression[?Yield]
// RelationalExpression[?In, ?Yield] <= ShiftExpression[?Yield]
// RelationalExpression[?In, ?Yield] >= ShiftExpression[?Yield]
// RelationalExpression[?In, ?Yield] instanceof ShiftExpression[?Yield]
// [+In] RelationalExpression[In, ?Yield] in ShiftExpression[?Yield]
relationalExpression
: shiftExpression
| relationalExpression '<' shiftExpression
| relationalExpression '>' shiftExpression
| relationalExpression '<=' shiftExpression
| relationalExpression '>=' shiftExpression
| relationalExpression 'instanceof' shiftExpression
;
relationalExpression_In
: shiftExpression
| relationalExpression_In '<' shiftExpression
| relationalExpression_In '>' shiftExpression
| relationalExpression_In '<=' shiftExpression
| relationalExpression_In '>=' shiftExpression
| relationalExpression_In 'instanceof' shiftExpression
| relationalExpression_In 'in' shiftExpression
;
relationalExpression_Yield
: shiftExpression_Yield
| relationalExpression_Yield '<' shiftExpression_Yield
| relationalExpression_Yield '>' shiftExpression_Yield
| relationalExpression_Yield '<=' shiftExpression_Yield
| relationalExpression_Yield '>=' shiftExpression_Yield
| relationalExpression_Yield 'instanceof' shiftExpression_Yield
;
relationalExpression_In_Yield
: shiftExpression_Yield
| relationalExpression_In_Yield '<' shiftExpression_Yield
| relationalExpression_In_Yield '>' shiftExpression_Yield
| relationalExpression_In_Yield '<=' shiftExpression_Yield
| relationalExpression_In_Yield '>=' shiftExpression_Yield
| relationalExpression_In_Yield 'instanceof' shiftExpression_Yield
| relationalExpression_In_Yield 'in' shiftExpression_Yield
;
// EqualityExpression[In, Yield] :
// RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield]
// EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield]
equalityExpression
: relationalExpression
| equalityExpression '==' relationalExpression
| equalityExpression '!=' relationalExpression
| equalityExpression '===' relationalExpression
| equalityExpression '!==' relationalExpression
;
equalityExpression_In
: relationalExpression_In
| equalityExpression_In '==' relationalExpression_In
| equalityExpression_In '!=' relationalExpression_In
| equalityExpression_In '===' relationalExpression_In
| equalityExpression_In '!==' relationalExpression_In
;
equalityExpression_Yield
: relationalExpression_Yield
| equalityExpression_Yield '==' relationalExpression_Yield
| equalityExpression_Yield '!=' relationalExpression_Yield
| equalityExpression_Yield '===' relationalExpression_Yield
| equalityExpression_Yield '!==' relationalExpression_Yield
;
equalityExpression_In_Yield
: relationalExpression_In_Yield
| equalityExpression_In_Yield '==' relationalExpression_In_Yield
| equalityExpression_In_Yield '!=' relationalExpression_In_Yield
| equalityExpression_In_Yield '===' relationalExpression_In_Yield
| equalityExpression_In_Yield '!==' relationalExpression_In_Yield
;
// BitwiseANDExpression[In, Yield] :
// EqualityExpression[?In, ?Yield]
// BitwiseANDExpression[?In, ?Yield] & EqualityExpression[?In, ?Yield]
bitwiseANDExpression
: equalityExpression
| bitwiseANDExpression '&' equalityExpression
;
bitwiseANDExpression_In
: equalityExpression_In
| bitwiseANDExpression_In '&' equalityExpression_In
;
bitwiseANDExpression_Yield
: equalityExpression_Yield
| bitwiseANDExpression_Yield '&' equalityExpression_Yield
;
bitwiseANDExpression_In_Yield
: equalityExpression_In_Yield
| bitwiseANDExpression_In_Yield '&' equalityExpression_In_Yield
;
// BitwiseXORExpression[In, Yield] :
// BitwiseANDExpression[?In, ?Yield]
// BitwiseXORExpression[?In, ?Yield] ^ BitwiseANDExpression[?In, ?Yield]
bitwiseXORExpression
: bitwiseANDExpression
| bitwiseXORExpression '^' bitwiseANDExpression
;
bitwiseXORExpression_In
: bitwiseANDExpression_In
| bitwiseXORExpression_In '^' bitwiseANDExpression_In
;
bitwiseXORExpression_Yield
: bitwiseANDExpression_Yield
| bitwiseXORExpression_Yield '^' bitwiseANDExpression_Yield
;
bitwiseXORExpression_In_Yield
: bitwiseANDExpression_In_Yield
| bitwiseXORExpression_In_Yield '^' bitwiseANDExpression_In_Yield
;
// BitwiseORExpression[In, Yield] :
// BitwiseXORExpression[?In, ?Yield]
// BitwiseORExpression[?In, ?Yield] | BitwiseXORExpression[?In, ?Yield]
bitwiseORExpression
: bitwiseXORExpression
| bitwiseORExpression '|' bitwiseXORExpression
;
bitwiseORExpression_In
: bitwiseXORExpression_In
| bitwiseORExpression_In '|' bitwiseXORExpression_In
;
bitwiseORExpression_Yield
: bitwiseXORExpression_Yield
| bitwiseORExpression_Yield '|' bitwiseXORExpression_Yield
;
bitwiseORExpression_In_Yield
: bitwiseXORExpression_In_Yield
| bitwiseORExpression_In_Yield '|' bitwiseXORExpression_In_Yield
;
// LogicalANDExpression[In, Yield] :
// BitwiseORExpression[?In, ?Yield]
// LogicalANDExpression[?In, ?Yield] && BitwiseORExpression[?In, ?Yield]
logicalANDExpression
: bitwiseORExpression
| logicalANDExpression '&&' bitwiseORExpression
;
logicalANDExpression_In
: bitwiseORExpression_In
| logicalANDExpression_In '&&' bitwiseORExpression_In
;
logicalANDExpression_Yield
: bitwiseORExpression_Yield
| logicalANDExpression_Yield '&&' bitwiseORExpression_Yield
;
logicalANDExpression_In_Yield
: bitwiseORExpression_In_Yield
| logicalANDExpression_In_Yield '&&' bitwiseORExpression_In_Yield
;
// LogicalORExpression[In, Yield] :
// LogicalANDExpression[?In, ?Yield]
// LogicalORExpression[?In, ?Yield] || LogicalANDExpression[?In, ?Yield]
logicalORExpression
: logicalANDExpression
| logicalORExpression '||' logicalANDExpression
;
logicalORExpression_In
: logicalANDExpression_In
| logicalORExpression_In '||' logicalANDExpression_In
;
logicalORExpression_Yield
: logicalANDExpression_Yield
| logicalORExpression_Yield '||' logicalANDExpression_Yield
;
logicalORExpression_In_Yield
: logicalANDExpression_In_Yield
| logicalORExpression_In_Yield '||' logicalANDExpression_In_Yield
;
// ConditionalExpression[In, Yield] :
// LogicalORExpression[?In, ?Yield]
// LogicalORExpression[?In, ?Yield] ? AssignmentExpression[In, ?Yield] : AssignmentExpression[?In, ?Yield]
conditionalExpression
: logicalORExpression
| logicalORExpression '?' assignmentExpression_In ':' assignmentExpression
;
conditionalExpression_In
: logicalORExpression_In
| logicalORExpression_In '?' assignmentExpression_In ':' assignmentExpression_In
;
conditionalExpression_Yield
: logicalORExpression_Yield
| logicalORExpression_Yield '?' assignmentExpression_In_Yield ':' assignmentExpression_Yield
;
conditionalExpression_In_Yield
: logicalORExpression_In_Yield
| logicalORExpression_In_Yield '?' assignmentExpression_In_Yield ':' assignmentExpression_In_Yield
;
// AssignmentExpression[In, Yield] :
// ConditionalExpression[?In, ?Yield]
// [+Yield] YieldExpression[?In]
// ArrowFunction[?In, ?Yield]
// LeftHandSideExpression[?Yield] = AssignmentExpression[?In, ?Yield]
// LeftHandSideExpression[?Yield] AssignmentOperator AssignmentExpression[?In, ?Yield]
assignmentExpression
: conditionalExpression
| arrowFunction
| leftHandSideExpression '=' assignmentExpression
| leftHandSideExpression AssignmentOperator assignmentExpression
;
assignmentExpression_In
: conditionalExpression_In
| arrowFunction_In
| leftHandSideExpression '=' assignmentExpression_In
| leftHandSideExpression AssignmentOperator assignmentExpression_In
;
assignmentExpression_Yield
: conditionalExpression_Yield
| yieldExpression
| arrowFunction_Yield
| leftHandSideExpression_Yield '=' assignmentExpression_Yield
| leftHandSideExpression_Yield AssignmentOperator assignmentExpression_Yield
;
assignmentExpression_In_Yield
: conditionalExpression_In_Yield
| yieldExpression_In
| arrowFunction_In_Yield
| leftHandSideExpression_Yield '=' assignmentExpression_In_Yield
| leftHandSideExpression_Yield AssignmentOperator assignmentExpression_In_Yield
;
// AssignmentOperator : one of
// *= /= %= += -= <<= >>= >>>= &= ^=
// |=
AssignmentOperator
: '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^='
| '|='
;
// Expression[In, Yield] :
// AssignmentExpression[?In, ?Yield]
// Expression[?In, ?Yield] , AssignmentExpression[?In, ?Yield]
expression
: assignmentExpression
| expression ',' assignmentExpression
;
expression_In
: assignmentExpression_In
| expression_In ',' assignmentExpression_In
;
expression_Yield
: assignmentExpression_Yield
| expression_Yield ',' assignmentExpression_Yield
;
expression_In_Yield
: assignmentExpression_In_Yield
| expression_In_Yield ',' assignmentExpression_In_Yield
;
// Statement[Yield, Return] :
// BlockStatement[?Yield, ?Return]
// VariableStatement[?Yield]
// EmptyStatement
// ExpressionStatement[?Yield]
// IfStatement[?Yield, ?Return]
// BreakableStatement[?Yield, ?Return]
// ContinueStatement[?Yield]
// BreakStatement[?Yield]
// [+Return] ReturnStatement[?Yield]
// WithStatement[?Yield, ?Return]
// LabelledStatement[?Yield, ?Return]
// ThrowStatement[?Yield]
// TryStatement[?Yield, ?Return]
// DebuggerStatement
statement
: blockStatement
| variableStatement
| EmptyStatement
| expressionStatement
| ifStatement
| breakableStatement
| continueStatement
| breakStatement
| withStatement
| labelledStatement
| throwStatement
| tryStatement
| DebuggerStatement
;
statement_Yield
: blockStatement_Yield
| variableStatement_Yield
| EmptyStatement
| expressionStatement_Yield
| ifStatement_Yield
| breakableStatement_Yield
| continueStatement_Yield
| breakStatement_Yield
| withStatement_Yield
| labelledStatement_Yield
| throwStatement_Yield
| tryStatement_Yield
| DebuggerStatement
;
statement_Return
: blockStatement_Return
| variableStatement
| EmptyStatement
| expressionStatement
| ifStatement_Return
| breakableStatement_Return
| continueStatement
| breakStatement
| returnStatement
| withStatement_Return
| labelledStatement_Return
| throwStatement
| tryStatement_Return
| DebuggerStatement
;
statement_Yield_Return
: blockStatement_Yield_Return
| variableStatement_Yield
| EmptyStatement
| expressionStatement_Yield
| ifStatement_Yield_Return
| breakableStatement_Yield_Return
| continueStatement_Yield
| breakStatement_Yield
| returnStatement_Yield
| withStatement_Yield_Return
| labelledStatement_Yield_Return
| throwStatement_Yield
| tryStatement_Yield_Return
| DebuggerStatement
;
// Declaration[Yield] :
// HoistableDeclaration[?Yield]
// ClassDeclaration[?Yield]
// LexicalDeclaration[In, ?Yield]
declaration
: hoistableDeclaration
| classDeclaration
| lexicalDeclaration_In
;
declaration_Yield
: hoistableDeclaration_Yield
| classDeclaration_Yield
| lexicalDeclaration_In_Yield
;
// HoistableDeclaration[Yield, Default] :
// FunctionDeclaration[?Yield, ?Default]
// GeneratorDeclaration[?Yield, ?Default]
hoistableDeclaration
: functionDeclaration
| generatorDeclaration
;
hoistableDeclaration_Yield
: functionDeclaration_Yield
| generatorDeclaration_Yield
;
hoistableDeclaration_Default
: functionDeclaration_Default
| generatorDeclaration_Default
;
hoistableDeclaration_Yield_Default
: functionDeclaration_Yield_Default
| generatorDeclaration_Yield_Default
;
// BreakableStatement[Yield, Return] :
// IterationStatement[?Yield, ?Return]
// SwitchStatement[?Yield, ?Return]
breakableStatement
: iterationStatement
| switchStatement
;
breakableStatement_Yield
: iterationStatement_Yield
| switchStatement_Yield
;
breakableStatement_Return
: iterationStatement_Return
| switchStatement_Return
;
breakableStatement_Yield_Return
: iterationStatement_Yield_Return
| switchStatement_Yield_Return
;
// BlockStatement[Yield, Return] :
// Block[?Yield, ?Return]
blockStatement
: block
;
blockStatement_Yield
: block_Yield
;
blockStatement_Return
: block_Return
;
blockStatement_Yield_Return
: block_Yield_Return
;
// Block[Yield, Return] :
// { StatementList[?Yield, ?Return]opt }
block
: '{' statementList? '}'
;
block_Yield
: '{' statementList_Yield? '}'
;
block_Return
: '{' statementList_Return? '}'
;
block_Yield_Return
: '{' statementList_Yield_Return? '}'
;
// StatementList[Yield, Return] :
// StatementListItem[?Yield, ?Return]
// StatementList[?Yield, ?Return] StatementListItem[?Yield, ?Return]
statementList
: statementListItem
| statementList statementListItem
;
statementList_Yield
: statementListItem_Yield
| statementList_Yield statementListItem_Yield
;
statementList_Return
: statementListItem_Return
| statementList_Return statementListItem_Return
;
statementList_Yield_Return
: statementListItem_Yield_Return
| statementList_Yield_Return statementListItem_Yield_Return
;
// StatementListItem[Yield, Return] :
// Statement[?Yield, ?Return]
// Declaration[?Yield]
statementListItem
: statement
| declaration
;
statementListItem_Yield
: statement_Yield
| declaration_Yield
;
statementListItem_Return
: statement_Return
| declaration
;
statementListItem_Yield_Return
: statement_Yield_Return
| declaration_Yield
;
// LexicalDeclaration[In, Yield] :
// LetOrConst BindingList[?In, ?Yield] ;
lexicalDeclaration
: LetOrConst bindingList ';'
;
lexicalDeclaration_In
: LetOrConst bindingList_In ';'
;
lexicalDeclaration_Yield
: LetOrConst bindingList_Yield ';'
;
lexicalDeclaration_In_Yield
: LetOrConst bindingList_In_Yield ';'
;
// LetOrConst :
// let
// const
LetOrConst
: 'let'
| 'const'
;
// BindingList[In, Yield] :
// LexicalBinding[?In, ?Yield]
// BindingList[?In, ?Yield] , LexicalBinding[?In, ?Yield]
bindingList
: lexicalBinding
| bindingList ',' lexicalBinding
;
bindingList_In
: lexicalBinding_In
| bindingList_In ',' lexicalBinding_In
;
bindingList_Yield
: lexicalBinding_Yield
| bindingList_Yield ',' lexicalBinding_Yield
;
bindingList_In_Yield
: lexicalBinding_In_Yield
| bindingList_In_Yield ',' lexicalBinding_In_Yield
;
// LexicalBinding[In, Yield] :
// BindingIdentifier[?Yield] Initializer[?In, ?Yield]opt
// BindingPattern[?Yield] Initializer[?In, ?Yield]
lexicalBinding
: bindingIdentifier initializer?
| bindingPattern initializer
;
lexicalBinding_In
: bindingIdentifier initializer_In?
| bindingPattern initializer_In
;
lexicalBinding_Yield
: bindingIdentifier_Yield initializer_Yield?
| bindingPattern_Yield initializer_Yield
;
lexicalBinding_In_Yield
: bindingIdentifier_Yield initializer_In_Yield?
| bindingPattern_Yield initializer_In_Yield
;
// VariableStatement[Yield] :
// var VariableDeclarationList[In, ?Yield] ;
variableStatement
: 'var' variableDeclarationList_In ';'
;
variableStatement_Yield
: 'var' variableDeclarationList_In_Yield ';'
;
// VariableDeclarationList[In, Yield] :
// VariableDeclaration[?In, ?Yield]
// VariableDeclarationList[?In, ?Yield] , VariableDeclaration[?In, ?Yield]
variableDeclarationList
: variableDeclaration
| variableDeclarationList ',' variableDeclaration
;
variableDeclarationList_In
: variableDeclaration_In
| variableDeclarationList_In ',' variableDeclaration_In
;
variableDeclarationList_Yield
: variableDeclaration_Yield
| variableDeclarationList_Yield ',' variableDeclaration_Yield
;
variableDeclarationList_In_Yield
: variableDeclaration_In_Yield
| variableDeclarationList_In_Yield ',' variableDeclaration_In_Yield
;
// VariableDeclaration[In, Yield] :
// BindingIdentifier[?Yield] Initializer[?In, ?Yield]opt
// BindingPattern[?Yield] Initializer[?In, ?Yield]
variableDeclaration
: bindingIdentifier initializer?
| bindingPattern initializer
;
variableDeclaration_In
: bindingIdentifier initializer_In?
| bindingPattern initializer_In
;
variableDeclaration_Yield
: bindingIdentifier_Yield initializer_Yield?
| bindingPattern_Yield initializer_Yield
;
variableDeclaration_In_Yield
: bindingIdentifier_Yield initializer_In_Yield?
| bindingPattern_Yield initializer_In_Yield
;
// BindingPattern[Yield] :
// ObjectBindingPattern[?Yield]
// ArrayBindingPattern[?Yield]
bindingPattern
: objectBindingPattern
| arrayBindingPattern
;
bindingPattern_Yield
: objectBindingPattern_Yield
| arrayBindingPattern_Yield
;
// ObjectBindingPattern[Yield] :
// { }
// { BindingPropertyList[?Yield] }
// { BindingPropertyList[?Yield] , }
objectBindingPattern
: '{' '}'
| '{' bindingPropertyList '}'
| '{' bindingPropertyList ',' '}'
;
objectBindingPattern_Yield
: '{' '}'
| '{' bindingPropertyList_Yield '}'
| '{' bindingPropertyList_Yield ',' '}'
;
// ArrayBindingPattern[Yield] :
// [ Elisionopt BindingRestElement[?Yield]opt ]
// [ BindingElementList[?Yield] ]
// [ BindingElementList[?Yield] , Elisionopt BindingRestElement[?Yield]opt ]
arrayBindingPattern
: '[' Elision? bindingRestElement? ']'
| '[' bindingElementList ']'
| '[' bindingElementList ',' Elision? bindingRestElement? ']'
;
arrayBindingPattern_Yield
: '[' Elision? bindingRestElement_Yield? ']'
| '[' bindingElementList_Yield ']'
| '[' bindingElementList_Yield ',' Elision? bindingRestElement_Yield? ']'
;
// BindingPropertyList[Yield] :
// BindingProperty[?Yield]
// BindingPropertyList[?Yield] , BindingProperty[?Yield]
bindingPropertyList
: bindingProperty
| bindingPropertyList ',' bindingProperty
;
bindingPropertyList_Yield
: bindingProperty_Yield
| bindingPropertyList_Yield ',' bindingProperty_Yield
;
// BindingElementList[Yield] :
// BindingElisionElement[?Yield]
// BindingElementList[?Yield] , BindingElisionElement[?Yield]
bindingElementList
: bindingElisionElement
| bindingElementList ',' bindingElisionElement
;
bindingElementList_Yield
: bindingElisionElement_Yield
| bindingElementList_Yield ',' bindingElisionElement_Yield
;
// BindingElisionElement[Yield] :
// Elisionopt BindingElement[?Yield]
bindingElisionElement
: Elision? bindingElement
;
bindingElisionElement_Yield
: Elision? bindingElement_Yield
;
// BindingProperty[Yield] :
// SingleNameBinding[?Yield]
// PropertyName[?Yield] : BindingElement[?Yield]
bindingProperty
: singleNameBinding
| propertyName ':' bindingElement
;
bindingProperty_Yield
: singleNameBinding_Yield
| propertyName_Yield ':' bindingElement_Yield
;
// BindingElement[Yield] :
// SingleNameBinding[?Yield]
// BindingPattern[?Yield] Initializer[In, ?Yield]opt
bindingElement
: singleNameBinding
| bindingPattern initializer_In?
;
bindingElement_Yield
: singleNameBinding_Yield
| bindingPattern_Yield initializer_In_Yield?
;
// SingleNameBinding[Yield] :
// BindingIdentifier[?Yield] Initializer[In, ?Yield]opt
singleNameBinding
: bindingIdentifier initializer?
;
singleNameBinding_Yield
: bindingIdentifier_Yield initializer_In_Yield?
;
// BindingRestElement[Yield] :
// ... BindingIdentifier[?Yield]
bindingRestElement
: '...' bindingIdentifier
;
bindingRestElement_Yield
: '...' bindingIdentifier_Yield
;
EmptyStatement
: ';'
;
// ExpressionStatement[Yield] :
// [lookahead ∉ { {, function, class, let [ }] Expression[In, ?Yield] ;
expressionStatement
: {(_input.LA(1) != '{') && (_input.LA(1) != 'function') && (_input.LA(1) != 'class') && (_input.LA(1) != 'let') && (_input.LA(1) != '[')}? expression ';'
;
expressionStatement_Yield
: {(_input.LA(1) != '{') && (_input.LA(1) != 'function') && (_input.LA(1) != 'class') && (_input.LA(1) != 'let') && (_input.LA(1) != '[')}? expression_In_Yield ';'
;
// IfStatement[Yield, Return] :
// if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return] else Statement[?Yield, ?Return]
// if ( Expression[In, ?Yield] ) Statement[?Yield, ?Return]
ifStatement
: 'if' ( expression_In ) statement 'else' statement
| 'if' ( expression_In ) statement
;
ifStatement_Yield
: 'if' ( expression_In_Yield ) statement_Yield 'else' statement_Yield
| 'if' ( expression_In_Yield ) statement_Yield
;
ifStatement_Return
: 'if' ( expression_In ) statement_Return 'else' statement_Return
| 'if' ( expression_In ) statement_Return
;
ifStatement_Yield_Return
: 'if' ( expression_In_Yield ) statement_Yield_Return 'else' statement_Yield_Return
| 'if' ( expression_In_Yield ) statement_Yield_Return
;
// IterationStatement[Yield, Return] :
// do Statement[?Yield, ?Return] while ( Expression[In, ?Yield] ) ;
// while ( Expression[In, ?Yield] ) Statement[?Yield, ?Return]
// for ( [lookahead ∉ { let [ }] Expression[?Yield]opt ; Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
// for ( var VariableDeclarationList[?Yield] ; Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
// for ( LexicalDeclaration[?Yield] Expression[In, ?Yield]opt ; Expression[In, ?Yield]opt ) Statement[?Yield, ?Return]
// for ( [lookahead ∉ { let [ }] LeftHandSideExpression[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]
// for ( var ForBinding[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]
// for ( ForDeclaration[?Yield] in Expression[In, ?Yield] ) Statement[?Yield, ?Return]
// for ( [lookahead ≠ let] LeftHandSideExpression[?Yield] of AssignmentExpression[In, ?Yield] ) Statement[?Yield, ?Return]
// for ( var ForBinding[?Yield] of AssignmentExpression[In, ?Yield] ) Statement[?Yield, ?Return]
// for ( ForDeclaration[?Yield] of AssignmentExpression[In, ?Yield] ) Statement[?Yield, ?Return]
iterationStatement
: 'do' statement 'while' '(' expression ')' ';'
| 'while' '(' expression ')' statement
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? expression? ';' expression? ';' expression? ')' statement
| 'for' '(' 'var' variableDeclarationList ';' expression? ';' expression? ')' statement
| 'for' '(' lexicalDeclaration expression? ';' expression? ')' statement
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? leftHandSideExpression 'in' expression ')' statement
| 'for' '(' 'var' forBinding 'in' expression ')' statement
| 'for' '(' forDeclaration 'in' expression ')' statement
| 'for' '(' {(_input.LA(1) != 'let')}? leftHandSideExpression 'of' assignmentExpression ')' statement
| 'for' '(' 'var' forBinding 'of' assignmentExpression ')' statement
| 'for' '(' forDeclaration 'of' assignmentExpression ')' statement
;
iterationStatement_Yield
: 'do' statement_Yield 'while' '(' expression_Yield ')' ';'
| 'while' '(' expression_Yield ')' statement_Yield
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? expression_Yield? ';' expression_Yield? ';' expression_Yield? ')' statement_Yield
| 'for' '(' 'var' variableDeclarationList_Yield ';' expression_Yield? ';' expression_Yield? ')' statement_Yield
| 'for' '(' lexicalDeclaration_Yield expression_Yield? ';' expression_Yield? ')' statement_Yield
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? leftHandSideExpression_Yield 'in' expression_Yield ')' statement_Yield
| 'for' '(' 'var' forBinding_Yield 'in' expression_Yield ')' statement_Yield
| 'for' '(' forDeclaration_Yield 'in' expression_Yield ')' statement_Yield
| 'for' '(' {(_input.LA(1) != 'let'))}? leftHandSideExpression_Yield 'of' assignmentExpression_Yield ')' statement_Yield
| 'for' '(' 'var' forBinding_Yield 'of' assignmentExpression_Yield ')' statement_Yield
| 'for' '(' forDeclaration_Yield 'of' assignmentExpression_Yield ')' statement_Yield
;
iterationStatement_Return
: 'do' statement_Return 'while' '(' expression_In ')' ';'
| 'while' '(' expression_In ')' statement_Return
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? expression? ';' expression_In? ';' expression_In? ')' statement_Return
| 'for' '(' 'var' variableDeclarationList ';' expression_In? ';' expression_In? ')' statement_Return
| 'for' '(' lexicalDeclaration expression_In? ';' expression_In? ')' statement_Return
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? leftHandSideExpression 'in' expression_In ')' statement_Return
| 'for' '(' 'var' forBinding 'in' expression_In ')' statement_Return
| 'for' '(' forDeclaration 'in' expression_In ')' statement_Return
| 'for' '(' {(_input.LA(1) != 'let'))}? leftHandSideExpression 'of' assignmentExpression_In ')' statement_Return
| 'for' '(' 'var' forBinding 'of' assignmentExpression_In ')' statement_Return
| 'for' '(' forDeclaration 'of' assignmentExpression_In ')' statement_Return
;
iterationStatement_Yield_Return
: 'do' statement_Yield_Return 'while' '(' expression_In_Yield ')' ';'
| 'while' '(' expression_In_Yield ')' statement_Yield_Return
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? expression_Yield? ';' expression_In_Yield? ';' expression_In_Yield? ')' statement_Yield_Return
| 'for' '(' 'var' variableDeclarationList_Yield ';' expression_In_Yield? ';' expression_In_Yield? ')' statement_Yield_Return
| 'for' '(' lexicalDeclaration_Yield expression_In_Yield? ';' expression_In_Yield? ')' statement_Yield_Return
| 'for' '(' {(_input.LA(1) != 'let') && (_input.LA(1) != '[')}? leftHandSideExpression_Yield 'in' expression_In_Yield ')' statement_Yield_Return
| 'for' '(' 'var' forBinding_Yield 'in' expression_In_Yield ')' statement_Yield_Return
| 'for' '(' forDeclaration_Yield 'in' expression_In_Yield ')' statement_Yield_Return
| 'for' '(' {(_input.LA(1) != 'let'))}? leftHandSideExpression_Yield 'of' assignmentExpression_In_Yield ')' statement_Yield_Return
| 'for' '(' 'var' forBinding_Yield 'of' assignmentExpression_In_Yield ')' statement_Yield_Return
| 'for' '(' forDeclaration_Yield 'of' assignmentExpression_In_Yield ')' statement_Yield_Return
;
// ForDeclaration[Yield] :
// LetOrConst ForBinding[?Yield]
forDeclaration
: LetOrConst forBinding
;
forDeclaration_Yield
: LetOrConst forBinding_Yield
;
// ForBinding[Yield] :
// BindingIdentifier[?Yield]
// BindingPattern[?Yield]
forBinding
: bindingIdentifier
| bindingPattern
;
forBinding_Yield
: bindingIdentifier_Yield
| bindingPattern_Yield
;
// ContinueStatement[Yield] :
// continue ;
// continue [no LineTerminator here] LabelIdentifier[?Yield] ;
continueStatement
: 'continue' ';'
| 'continue' ~LineTerminator labelIdentifier ';'
;
continueStatement_Yield
: 'continue' ';'
| 'continue' ~LineTerminator labelIdentifier_Yield ';'
;
// BreakStatement[Yield] :
// break ;
// break [no LineTerminator here] LabelIdentifier[?Yield] ;
breakStatement
: 'break' ';'
| 'break' ~LineTerminator labelIdentifier ';'
;
breakStatement_Yield
: 'break' ';'
| 'break' ~LineTerminator labelIdentifier_Yield ';'
;
// ReturnStatement[Yield] :
// return ;
// return [no LineTerminator here] Expression[In, ?Yield] ;
returnStatement
: 'return' ';'
| 'return' ~LineTerminator expression_In ';'
;
returnStatement_Yield
: 'return' ';'
| 'return' ~LineTerminator expression_In_Yield ';'
;
// WithStatement[Yield, Return] :
// with ( Expression[In, ?Yield] ) Statement[?Yield, ?Return]
withStatement
: 'with' '(' expression_Yield ')' statement
;
withStatement_Yield
: 'with' '(' expression_In_Yield ')' statement_Yield
;
withStatement_Return
: 'with' '(' expression_In ')' statement_Return
;
withStatement_Yield_Return
: 'with' '(' expression_In_Yield ')' statement_Yield_Return
;
// SwitchStatement[Yield, Return] :
// switch ( Expression[In, ?Yield] ) CaseBlock[?Yield, ?Return]
switchStatement
: 'switch' '(' expression_In ')' caseBlock
;
switchStatement_Yield
: 'switch' '(' expression_In_Yield ')' caseBlock_Yield
;
switchStatement_Return
: 'switch' '(' expression_In ')' caseBlock_Return
;
switchStatement_Yield_Return
: 'switch' '(' expression_In_Yield ')' caseBlock_Yield_Return
;
// CaseBlock[Yield, Return] :
// { CaseClauses[?Yield, ?Return]opt }
// { CaseClauses[?Yield, ?Return]opt DefaultClause[?Yield, ?Return] CaseClauses[?Yield, ?Return]opt }
caseBlock
: '{' caseClauses? '}'
| '{' caseClauses? defaultClause caseClauses? '}'
;
caseBlock_Yield
: '{' caseClauses_Yield? '}'
| '{' caseClauses_Yield? defaultClause_Yield caseClauses_Yield? '}'
;
caseBlock_Return
: '{' caseClauses_Return? '}'
| '{' caseClauses_Return? defaultClause_Return caseClauses_Return? '}'
;
caseBlock_Yield_Return
: '{' caseClauses_Yield_Return? '}'
| '{' caseClauses_Yield_Return? defaultClause_Yield_Return caseClauses_Yield_Return? '}'
;
// CaseClauses[Yield, Return] :
// CaseClause[?Yield, ?Return]
// CaseClauses[?Yield, ?Return] CaseClause[?Yield, ?Return]
caseClauses
: caseClause
| caseClauses caseClause
;
caseClauses_Yield
: caseClause_Yield
| caseClauses_Yield caseClause_Yield
;
caseClauses_Return
: caseClause_Return
| caseClauses_Return caseClause_Return
;
caseClauses_Yield_Return
: caseClause_Yield_Return
| caseClauses_Yield_Return caseClause_Yield_Return
;
// CaseClause[Yield, Return] :
// case Expression[In, ?Yield] : StatementList[?Yield, ?Return]opt
caseClause
: 'case' expression_In ':' statementList?
;
caseClause_Yield
: 'case' expression_In_Yield ':' statementList_Yield?
;
caseClause_Return
: 'case' expression_In ':' statementList_Return?
;
caseClause_Yield_Return
: 'case' expression_In_Yield ':' statementList_Yield_Return?
;
// DefaultClause[Yield, Return] :
// default : StatementList[?Yield, ?Return]opt
defaultClause
: 'default' ':' statementList?
;
defaultClause_Yield
: 'default' ':' statementList_Yield?
;
defaultClause_Return
: 'default' ':' statementList_Return?
;
defaultClause_Yield_Return
: 'default' ':' statementList_Yield_Return?
;
// LabelledStatement[Yield, Return] :
// LabelIdentifier[?Yield] : LabelledItem[?Yield, ?Return]
labelledStatement
: labelIdentifier ':' labelledItem
;
labelledStatement_Yield
: labelIdentifier_Yield ':' labelledItem_Yield
;
labelledStatement_Return
: labelIdentifier ':' labelledItem_Return
;
labelledStatement_Yield_Return
: labelIdentifier_Yield ':' labelledItem_Yield_Return
;
// LabelledItem[Yield, Return] :
// Statement[?Yield, ?Return]
// FunctionDeclaration[?Yield]
labelledItem
: statement
| functionDeclaration
;
labelledItem_Yield
: statement_Yield
| functionDeclaration_Yield
;
labelledItem_Return
: statement_Return
| functionDeclaration
;
labelledItem_Yield_Return
: statement_Yield_Return
| functionDeclaration_Yield
;
// ThrowStatement[Yield] :
// throw [no LineTerminator here] Expression[In, ?Yield] ;
throwStatement
: 'throw' ~LineTerminator expression_In ';'
;
throwStatement_Yield
: 'throw' ~LineTerminator expression_In_Yield ';'
;
// TryStatement[Yield, Return] :
// try Block[?Yield, ?Return] Catch[?Yield, ?Return]
// try Block[?Yield, ?Return] Finally[?Yield, ?Return]
// try Block[?Yield, ?Return] Catch[?Yield, ?Return] Finally[?Yield, ?Return]
tryStatement
: 'try' block catchStatement
| 'try' block finallyStatement
| 'try' block catchStatement finallyStatement
;
tryStatement_Yield
: 'try' block_Yield catch_Yield
| 'try' block_Yield finally_Yield
| 'try' block_Yield catch_Yield finally_Yield
;
tryStatement_Return
: 'try' block_Return catch_Return
| 'try' block_Return finally_Return
| 'try' block_Return catch_Return finally_Return
;
tryStatement_Yield_Return
: 'try' block_Yield_Return catch_Yield_Return
| 'try' block_Yield_Return finally_Yield_Return
| 'try' block_Yield_Return catch_Yield_Return finally_Yield_Return
;
// Catch[Yield, Return] :
// catch ( CatchParameter[?Yield] ) Block[?Yield, ?Return]
catchStatement
: 'catch' '(' catchParameter ')' block
;
catch_Yield
: 'catch' '(' catchParameter_Yield ')' block_Yield
;
catch_Return
: 'catch' '(' catchParameter ')' block_Return
;
catch_Yield_Return
: 'catch' '(' catchParameter_Yield ')' block_Yield_Return
;
// Finally[Yield, Return] :
// finally Block[?Yield, ?Return]
finallyStatement
: 'finally' block
;
finally_Yield
: 'finally' block_Yield
;
finally_Return
: 'finally' block_Return
;
finally_Yield_Return
: 'finally' block_Yield_Return
;
// CatchParameter[Yield] :
// BindingIdentifier[?Yield]
// BindingPattern[?Yield]
catchParameter
: bindingIdentifier
| bindingPattern
;
catchParameter_Yield
: bindingIdentifier_Yield
| bindingPattern_Yield
;
// DebuggerStatement :
// debugger ;
DebuggerStatement
: 'debugger' ';'
;
// FunctionDeclaration[Yield, Default] :
// function BindingIdentifier[?Yield] ( FormalParameters ) { FunctionBody }
// [+Default] function ( FormalParameters ) { FunctionBody }
functionDeclaration
: 'function' bindingIdentifier '(' formalParameters ')' '{' functionBody '}'
| 'function' '(' formalParameters ')' '{' functionBody '}'
;
functionDeclaration_Yield
: 'function' bindingIdentifier_Yield '(' formalParameters ')' '{' functionBody '}'
| 'function' '(' formalParameters ')' '{' functionBody '}'
;
functionDeclaration_Default
: 'function' bindingIdentifier '(' formalParameters ')' '{' functionBody '}'
| 'function' '(' formalParameters ')' '{' functionBody '}'
;
functionDeclaration_Yield_Default
: 'function' bindingIdentifier_Yield '(' formalParameters ')' '{' functionBody '}'
| 'function' '(' formalParameters ')' '{' functionBody '}'
;
// FunctionExpression :
// function BindingIdentifieropt ( FormalParameters ) { FunctionBody }
functionExpression
: 'function' bindingIdentifier? '(' formalParameters ')' '{' functionBody '}'
;
// StrictFormalParameters[Yield] :
// FormalParameters[?Yield]
strictFormalParameters
: formalParameters
;
strictFormalParameters_Yield
: formalParameters_Yield
;
// FormalParameters[Yield] :
// [empty]
// FormalParameterList[?Yield]
formalParameters
: //[empty]
| formalParameterList
;
formalParameters_Yield
: //[empty]
| formalParameterList_Yield
;
// FormalParameterList[Yield] :
// FunctionRestParameter[?Yield]
// FormalsList[?Yield]
// FormalsList[?Yield] , FunctionRestParameter[?Yield]
formalParameterList
: functionRestParameter
| formalsList
| formalsList ',' functionRestParameter
;
formalParameterList_Yield
: functionRestParameter_Yield
| formalsList_Yield
| formalsList_Yield ',' functionRestParameter_Yield
;
// FormalsList[Yield] :
// FormalParameter[?Yield]
// FormalsList[?Yield] , FormalParameter[?Yield]
formalsList
: formalParameter
| formalsList ',' formalParameter
;
formalsList_Yield
: formalParameter_Yield
| formalsList_Yield ',' formalParameter_Yield
;
// FunctionRestParameter[Yield] :
// BindingRestElement[?Yield]
functionRestParameter
: bindingRestElement
;
functionRestParameter_Yield
: bindingRestElement_Yield
;
// FormalParameter[Yield] :
// BindingElement[?Yield]
formalParameter
: bindingElement
;
formalParameter_Yield
: bindingElement_Yield
;
// FunctionBody[Yield] :
// FunctionStatementList[?Yield]
functionBody
: functionStatementList
;
functionBody_Yield
: functionStatementList_Yield
;
// FunctionStatementList[Yield] :
// StatementList[?Yield, Return]opt
functionStatementList
: statementList_Yield?
;
functionStatementList_Yield
: statementList_Yield_Return?
;
// ArrowFunction[In, Yield] :
// ArrowParameters[?Yield] [no LineTerminator here] => ConciseBody[?In]
arrowFunction
: arrowParameters ~LineTerminator '=>' conciseBody
;
arrowFunction_In
: arrowParameters ~LineTerminator '=>' conciseBody_In
;
arrowFunction_Yield
: arrowParameters_Yield ~LineTerminator '=>' conciseBody
;
arrowFunction_In_Yield
: arrowParameters_Yield ~LineTerminator '=>' conciseBody_In
;
// ArrowParameters[Yield] :
// BindingIdentifier[?Yield]
// CoverParenthesizedExpressionAndArrowParameterList[?Yield]
arrowParameters
: bindingIdentifier
| coverParenthesizedExpressionAndArrowParameterList
;
arrowParameters_Yield
: bindingIdentifier_Yield
| coverParenthesizedExpressionAndArrowParameterList_Yield
;
// ConciseBody[In] :
// [lookahead ≠ {] AssignmentExpression[?In]
// { FunctionBody }
conciseBody
: {(_input.LA(1) != '{')}? assignmentExpression
| '{' functionBody '}'
;
conciseBody_In
: {(_input.LA(1) != '{'))}? assignmentExpression_In
| '{' functionBody '}'
;
// MethodDefinition[Yield] :
// PropertyName[?Yield] ( StrictFormalParameters ) { FunctionBody }
// GeneratorMethod[?Yield]
// get PropertyName[?Yield] ( ) { FunctionBody }
// set PropertyName[?Yield] ( PropertySetParameterList ) { FunctionBody }
methodDefinition
: propertyName '(' strictFormalParameters ')' '{' functionBody '}'
| generatorMethod
| 'get 'propertyName '(' ')' '{' functionBody '}'
| 'set' propertyName '(' propertySetParameterList ')' '{' functionBody '}'
;
methodDefinition_Yield
: propertyName_Yield '(' strictFormalParameters ')' '{' functionBody '}'
| generatorMethod_Yield
| 'get 'propertyName_Yield '(' ')' '{' functionBody '}'
| 'set' propertyName_Yield '(' propertySetParameterList ')' '{' functionBody '}'
;
// PropertySetParameterList :
// FormalParameter
propertySetParameterList
: formalParameter
;
// GeneratorMethod[Yield] :
// * PropertyName[?Yield] ( StrictFormalParameters[Yield] ) { GeneratorBody }
generatorMethod
: '*' propertyName ( strictFormalParameters ) '{' generatorBody '}'
;
generatorMethod_Yield
: '*' propertyName_Yield ( strictFormalParameters_Yield ) '{' generatorBody '}'
;
// GeneratorDeclaration[Yield, Default] :
// function * BindingIdentifier[?Yield] ( FormalParameters[Yield] ) { GeneratorBody }
// [+Default] function * ( FormalParameters[Yield] ) { GeneratorBody }
generatorDeclaration
: 'function' '*' bindingIdentifier '(' formalParameters_Yield ')' '{' generatorBody '}'
;
generatorDeclaration_Yield
: 'function' '*' bindingIdentifier_Yield '(' formalParameters_Yield ')' '{' generatorBody '}'
;
generatorDeclaration_Default
: 'function' '*' bindingIdentifier_Yield '(' formalParameters_Yield ')' '{' generatorBody '}'
| 'function' '*' '(' formalParameters_Yield ')' '{' generatorBody '}'
;
generatorDeclaration_Yield_Default
: 'function' '*' bindingIdentifier_Yield '(' formalParameters_Yield ')' '{' generatorBody '}'
| 'function' '*' '(' formalParameters_Yield ')' '{' generatorBody '}'
;
// GeneratorExpression :
// function * BindingIdentifier[Yield]opt ( FormalParameters[Yield] ) { GeneratorBody }
generatorExpression
: 'function' '*' bindingIdentifier_Yield? '(' formalParameters_Yield ')' '{' generatorBody '}'
;
// GeneratorBody :
// FunctionBody[Yield]
generatorBody
: functionBody_Yield
;
// YieldExpression[In] :
// yield
// yield [no LineTerminator here] AssignmentExpression[?In, Yield]
// yield [no LineTerminator here] * AssignmentExpression[?In, Yield]
yieldExpression
: 'yield'
| 'yield' ~LineTerminator assignmentExpression_Yield
| 'yield' ~LineTerminator '*' assignmentExpression_Yield
;
yieldExpression_In
: 'yield'
| 'yield' ~LineTerminator assignmentExpression_In_Yield
| 'yield' ~LineTerminator '*' assignmentExpression_In_Yield
;
// ClassDeclaration[Yield, Default] :
// class BindingIdentifier[?Yield] ClassTail[?Yield]
// [+Default] class ClassTail[?Yield]
classDeclaration
: 'class' bindingIdentifier classTail
;
classDeclaration_Yield
: 'class' bindingIdentifier_Yield classTail_Yield
;
classDeclaration_Default
: 'class' bindingIdentifier classTail
| 'class' classTail
;
classDeclaration_Yield_Default
: 'class' bindingIdentifier_Yield classTail_Yield
| 'class' classTail_Yield
;
// ClassExpression[Yield] :
// class BindingIdentifier[?Yield]opt ClassTail[?Yield]
classExpression
: 'class' bindingIdentifier? classTail
;
classExpression_Yield
: 'class' bindingIdentifier_Yield? classTail_Yield
;
// ClassTail[Yield] :
// ClassHeritage[?Yield]opt { ClassBody[?Yield]opt }
classTail
: classHeritage? '{' classBody? '}'
;
classTail_Yield
: classHeritage_Yield? '{' classBody_Yield? '}'
;
// ClassHeritage[Yield] :
// extends LeftHandSideExpression[?Yield]
classHeritage
: 'extends' leftHandSideExpression
;
classHeritage_Yield
: 'extends' leftHandSideExpression_Yield
;
// ClassBody[Yield] :
// ClassElementList[?Yield]
classBody
: classElementList
;
classBody_Yield
: classElementList_Yield
;
// ClassElementList[Yield] :
// ClassElement[?Yield]
// ClassElementList[?Yield] ClassElement[?Yield]
classElementList
: classElement
| classElementList classElement
;
classElementList_Yield
: classElement_Yield
| classElementList_Yield classElement_Yield
;
// ClassElement[Yield] :
// MethodDefinition[?Yield]
// static MethodDefinition[?Yield]
// ;
classElement
: methodDefinition
| 'static' methodDefinition
| ';'
;
classElement_Yield
: methodDefinition_Yield
| 'static' methodDefinition_Yield
| ';'
;
// Script :
// ScriptBodyopt
script
: scriptBody?
;
// ScriptBody :
// StatementList
scriptBody
: statementList;
// Module :
// ModuleBodyopt
module
: moduleBody?;
// ModuleBody :
// ModuleItemList
moduleBody
: moduleItemList;
// ModuleItemList :
// ModuleItem
// ModuleItemList ModuleItem
moduleItemList
: moduleItem
| moduleItemList moduleItem;
// ModuleItem :
// ImportDeclaration
// ExportDeclaration
// StatementListItem
moduleItem
: importDeclaration
| exportDeclaration
| statementListItem;
// ImportDeclaration :
// import ImportClause FromClause ;
// import ModuleSpecifier ;
importDeclaration
: 'import' importClause FromClause ';'
| 'import' ModuleSpecifier ';'
;
// ImportClause :
// ImportedDefaultBinding
// NameSpaceImport
// NamedImports
// ImportedDefaultBinding , NameSpaceImport
// ImportedDefaultBinding , NamedImports
importClause
: importedDefaultBinding
| nameSpaceImport
| namedImports
| importedDefaultBinding ',' nameSpaceImport
| importedDefaultBinding ',' namedImports
;
// ImportedDefaultBinding :
// ImportedBinding
importedDefaultBinding
: importedBinding;
// NameSpaceImport :
// * as ImportedBinding
nameSpaceImport
: '*' 'as' importedBinding;
// NamedImports :
// { }
// { ImportsList }
// { ImportsList , }
namedImports
: '{' '}'
| '{' importsList '}'
| '{' importsList ',' '}'
;
// FromClause :
// from ModuleSpecifier
FromClause
: 'from' ModuleSpecifier
;
// ImportsList :
// ImportSpecifier
// ImportsList , ImportSpecifier
importsList
: importSpecifier
| importsList ',' importSpecifier
;
// ImportSpecifier :
// ImportedBinding
// IdentifierName as ImportedBinding
importSpecifier
: importedBinding
| IdentifierName 'as' importedBinding
;
// ModuleSpecifier :
// StringLiteral
ModuleSpecifier
: StringLiteral
;
// ImportedBinding :
// BindingIdentifier
importedBinding
: bindingIdentifier
;
// ExportDeclaration :
// export * FromClause ;
// export ExportClause FromClause ;
// export ExportClause ;
// export VariableStatement
// export Declaration
// export default HoistableDeclaration[Default]
// export default ClassDeclaration[Default]
// export default [lookahead ∉ { function, class }] AssignmentExpression[In] ;
exportDeclaration
: 'export' '*' FromClause ';'
| 'export' exportClause FromClause ';'
| 'export' exportClause ';'
| 'export' variableStatement
| 'export' declaration
| 'export' 'default' hoistableDeclaration_Default
| 'export' 'default' classDeclaration_Default
| 'export' 'default' {(_input.LA(1) != 'function') && (_input.LA(1) != 'class')}? assignmentExpression_In ';'
;
// ExportClause :
// { }
// { ExportsList }
// { ExportsList , }
exportClause
: '{' '}'
| '{' exportsList '}'
| '{' exportsList ',' '}'
;
// ExportsList :
// ExportSpecifier
// ExportsList , ExportSpecifier
exportsList
: ExportSpecifier
| exportsList ',' ExportSpecifier
;
// ExportSpecifier :
// IdentifierName
// IdentifierName as IdentifierName
ExportSpecifier
: IdentifierName
| IdentifierName 'as' IdentifierName
;
|
libsrc/_DEVELOPMENT/math/float/math48/lm/c/sccz80/remquo.asm | jpoikela/z88dk | 640 | 4499 |
SECTION code_clib
SECTION code_fp_math48
PUBLIC remquo
EXTERN cm48_sccz80_remquo
defc remquo = cm48_sccz80_remquo
|
examples/Quicksort/output.asm | mkiesinger/HackVM-to-MiMa | 1 | 163243 | * = 0
JMP START
* = 1
LCL: DS 0
ARG: DS 0
THIS: DS 0
THAT: DS 0
TEMP0: DS 0
TEMP1: DS 0
TEMP2: DS 0
TEMP3: DS 0
TEMP4: DS 0
TEMP5: DS 0
TEMP6: DS 0
TEMP7: DS 0
SP: DS 0
T0: DS 0
T1: DS 0
* = 16
* = 32768
START: JMP Setup
MONE: DS 65535
MONECF: DS -1
MFIVECF: DS -5
NFLAG: DS 32768
Setup: LDC 256
STV SP
JMP Sys.init
Sys.halt: AND MONECF
Sys.halt.WHILE_EXP0: LDC 0
ADD MONECF
NOT
JMN Sys.halt.WHILE_END0
JMP Sys.halt.WHILE_EXP0
Sys.halt.WHILE_END0: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Sys.init: LDC Sys.Sys.init.ret.0
STIV SP
LDC Main.main
STV T0
LDC 4
STV T1
JMP CALL
Sys.Sys.init.ret.0: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC Sys.Sys.init.ret.2
STIV SP
LDC Sys.halt
STV T0
LDC 4
STV T1
JMP CALL
Sys.Sys.init.ret.2: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Main.quickSort: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
ADD ARG
STV T0
LDIV T0
STIV SP
LDC 0
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 2
ADD ARG
STV T0
LDIV T0
STIV SP
LDC 1
ADD LCL
STV T0
LDIV SP
STIV T0
Main.quickSort.WHILE_EXP0: LDC 1
ADD LCL
STV T1
LDIV T1
ADD MONE
NOT
STV T1
LDC 0
ADD LCL
STV T0
LDIV T0
ADD T1
AND NFLAG
EQL NFLAG
AND MONE
NOT
AND MONE
ADD MONECF
NOT
JMN Main.quickSort.WHILE_END0
LDC 0
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 2
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 1
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 3
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 0
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STV THAT
LDC 0
ADD THAT
STV T0
LDIV T0
STIV SP
LDC 5
ADD LCL
STV T0
LDIV SP
STIV T0
Main.quickSort.WHILE_EXP1: LDC 2
ADD LCL
STV T0
LDIV T0
ADD MONE
NOT
STV T0
LDC 3
ADD LCL
STV T1
LDIV T1
ADD T0
AND NFLAG
EQL NFLAG
AND MONE
ADD MONECF
NOT
JMN Main.quickSort.WHILE_END1
Main.quickSort.WHILE_EXP2: LDC 2
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STV THAT
LDC 5
ADD LCL
STV T1
LDIV T1
ADD MONE
NOT
STV T1
LDC 0
ADD THAT
STV T0
LDIV T0
ADD T1
AND NFLAG
EQL NFLAG
AND MONE
NOT
AND MONE
ADD MONECF
NOT
JMN Main.quickSort.WHILE_END2
LDC 2
ADD LCL
STV T0
LDIV T0
STV T0
LDC 1
ADD T0
AND MONE
STIV SP
LDC 2
ADD LCL
STV T0
LDIV SP
STIV T0
JMP Main.quickSort.WHILE_EXP2
Main.quickSort.WHILE_END2: AND MONECF
Main.quickSort.WHILE_EXP3: LDC 5
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 3
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STV THAT
LDC 0
ADD THAT
STV T0
LDIV T0
ADD MONECF
NOT
STV T0
LDV MONECF
ADD SP
STV SP
LDIV SP
ADD T0
AND NFLAG
EQL NFLAG
AND MONE
NOT
AND MONE
ADD MONECF
NOT
JMN Main.quickSort.WHILE_END3
LDC 1
ADD MONE
NOT
STV T1
LDC 3
ADD LCL
STV T0
LDIV T0
ADD T1
AND MONE
STIV SP
LDC 3
ADD LCL
STV T0
LDIV SP
STIV T0
JMP Main.quickSort.WHILE_EXP3
Main.quickSort.WHILE_END3: LDC 2
ADD LCL
STV T0
LDIV T0
ADD MONE
NOT
STV T0
LDC 3
ADD LCL
STV T1
LDIV T1
ADD T0
AND NFLAG
EQL NFLAG
AND MONE
NOT
AND MONE
ADD MONECF
NOT
JMN Main.quickSort.IF_TRUE0
JMP Main.quickSort.IF_FALSE0
Main.quickSort.IF_TRUE0: LDC 2
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STV THAT
LDC 0
ADD THAT
STV T0
LDIV T0
STIV SP
LDC 4
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 2
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 3
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STV THAT
LDC 0
ADD THAT
STV T0
LDIV T0
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 3
ADD LCL
STV T0
LDIV T0
STV T0
LDC 0
ADD ARG
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 4
ADD LCL
STV T0
LDIV T0
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 2
ADD LCL
STV T0
LDIV T0
STV T0
LDC 1
ADD T0
AND MONE
STIV SP
LDC 2
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 1
ADD MONE
NOT
STV T1
LDC 3
ADD LCL
STV T0
LDIV T0
ADD T1
AND MONE
STIV SP
LDC 3
ADD LCL
STV T0
LDIV SP
STIV T0
Main.quickSort.IF_FALSE0: JMP Main.quickSort.WHILE_EXP1
Main.quickSort.WHILE_END1: LDC 2
ADD LCL
STV T0
LDIV T0
STV T0
LDC 2
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
ADD LCL
STV T0
LDIV T0
ADD MONECF
NOT
STV T0
LDV MONECF
ADD SP
STV SP
LDIV SP
ADD T0
AND NFLAG
EQL NFLAG
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
ADD LCL
STV T0
LDIV T0
STV T0
LDV MONECF
ADD SP
STV SP
LDIV SP
ADD T0
AND MONE
ADD MONECF
NOT
JMN Main.quickSort.IF_TRUE1
JMP Main.quickSort.IF_FALSE1
Main.quickSort.IF_TRUE1: LDC 0
ADD ARG
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 3
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC Main.Main.quickSort.IF_TRUE1.ret.3
STIV SP
LDC Main.quickSort
STV T0
LDC 7
STV T1
JMP CALL
Main.Main.quickSort.IF_TRUE1.ret.3: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC 2
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 0
ADD LCL
STV T0
LDIV SP
STIV T0
JMP Main.quickSort.IF_END1
Main.quickSort.IF_FALSE1: LDC 0
ADD ARG
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 2
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC Main.Main.quickSort.IF_FALSE1.ret.3
STIV SP
LDC Main.quickSort
STV T0
LDC 7
STV T1
JMP CALL
Main.Main.quickSort.IF_FALSE1.ret.3: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC 3
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD LCL
STV T0
LDIV SP
STIV T0
Main.quickSort.IF_END1: JMP Main.quickSort.WHILE_EXP0
Main.quickSort.WHILE_END0: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
Main.main: LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 16384
STIV SP
LDC 0
ADD LCL
STV T0
LDIV SP
STIV T0
LDC 0
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 18
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 1
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 6
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 2
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
ADD MONECF
NOT
AND MONE
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 3
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 1
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 4
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 13
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 5
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 11
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 6
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 5
ADD MONECF
NOT
AND MONE
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 7
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 8
ADD MONECF
NOT
AND MONE
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 8
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 3
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 9
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 7
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 10
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 5
ADD MONECF
NOT
AND MONE
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 11
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 6
ADD MONECF
NOT
AND MONE
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 12
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 15
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 13
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 15
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 14
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 2
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 15
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 3
ADD MONECF
NOT
AND MONE
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 16
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 16
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 17
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 2
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 18
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 11
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 19
STV T0
LDC 0
ADD LCL
STV T1
LDIV T1
ADD T0
AND MONE
STIV SP
LDC 1
ADD SP
STV SP
LDC 10
STV TEMP0
LDV MONECF
ADD SP
STV SP
LDIV SP
STV THAT
LDV TEMP0
STIV SP
LDC 0
ADD THAT
STV T0
LDIV SP
STIV T0
LDC 0
ADD LCL
STV T0
LDIV T0
STIV SP
LDC 1
ADD SP
STV SP
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
LDC 19
STIV SP
LDC 1
ADD SP
STV SP
LDC Main.Main.main.ret.131
STIV SP
LDC Main.quickSort
STV T0
LDC 7
STV T1
JMP CALL
Main.Main.main.ret.131: LDV MONECF
ADD SP
STV SP
LDIV SP
STV TEMP0
LDC 0
STIV SP
LDC 1
ADD SP
STV SP
JMP RETURN
CALL: LDC 1
ADD SP
STV SP
LDV LCL
STIV SP
LDC 1
ADD SP
STV SP
LDV ARG
STIV SP
LDC 1
ADD SP
STV SP
LDV THIS
STIV SP
LDC 1
ADD SP
STV SP
LDV THAT
STIV SP
LDC 1
ADD SP
STV SP
LDV T1
NOT
ADD SP
STV ARG
LDV SP
STV LCL
JIND T0
RETURN: LDV LCL
STV T0
ADD MFIVECF
STV T1
LDIV T1
STV T1
LDV MONECF
ADD SP
STV SP
LDIV SP
STIV ARG
LDC 1
ADD ARG
STV SP
LDV MONECF
ADD T0
STV T0
LDIV T0
STV THAT
LDV MONECF
ADD T0
STV T0
LDIV T0
STV THIS
LDV MONECF
ADD T0
STV T0
LDIV T0
STV ARG
LDV MONECF
ADD T0
STV T0
LDIV T0
STV LCL
JIND T1
// Labels for easier result checking
* = 16384
SCREEN0: DS 0
SCREEN1: DS 0
SCREEN2: DS 0
SCREEN3: DS 0
SCREEN4: DS 0
SCREEN5: DS 0
SCREEN6: DS 0
SCREEN7: DS 0
SCREEN8: DS 0
SCREEN9: DS 0
SCREEN10: DS 0
SCREEN11: DS 0
SCREEN12: DS 0
SCREEN13: DS 0
SCREEN14: DS 0
SCREEN15: DS 0
SCREEN16: DS 0
SCREEN17: DS 0
SCREEN18: DS 0
SCREEN19: DS 0
|
Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_1951.asm | ljhsiun2/medusa | 9 | 14848 | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r15
push %r8
push %rax
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_normal_ht+0x5786, %rbx
nop
and %rax, %rax
movb (%rbx), %r13b
nop
nop
nop
nop
inc %r13
lea addresses_UC_ht+0x1433a, %r8
nop
nop
nop
inc %rdx
movups (%r8), %xmm1
vpextrq $1, %xmm1, %r10
nop
nop
nop
nop
xor %r10, %r10
lea addresses_A_ht+0xa236, %r10
clflush (%r10)
nop
nop
nop
nop
and $52323, %r13
mov (%r10), %rdx
nop
cmp $52283, %rdx
lea addresses_A_ht+0x8076, %rdx
nop
nop
nop
nop
nop
sub %r15, %r15
movups (%rdx), %xmm6
vpextrq $0, %xmm6, %rbx
nop
nop
nop
and $27213, %r13
lea addresses_normal_ht+0x1124e, %r8
dec %r13
movb (%r8), %dl
nop
nop
nop
nop
nop
cmp %rax, %rax
lea addresses_UC_ht+0xcd7c, %rsi
lea addresses_WT_ht+0xc196, %rdi
nop
nop
dec %r13
mov $115, %rcx
rep movsl
nop
nop
nop
cmp $5339, %rcx
lea addresses_D_ht+0xdafe, %rsi
lea addresses_UC_ht+0xccb5, %rdi
nop
inc %r8
mov $103, %rcx
rep movsl
nop
nop
and $2556, %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r8
pop %r15
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r9
push %rdi
push %rsi
// Faulty Load
lea addresses_UC+0x1da36, %r9
nop
nop
and $27928, %r10
mov (%r9), %di
lea oracles, %rsi
and $0xff, %rdi
shlq $12, %rdi
mov (%rsi,%rdi,1), %rdi
pop %rsi
pop %rdi
pop %r9
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'AVXalign': False, 'congruent': 0, 'size': 16, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_UC', 'AVXalign': False, 'congruent': 0, 'size': 2, 'same': True, 'NT': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 2, 'size': 1, 'same': True, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'AVXalign': False, 'congruent': 2, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 11, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'congruent': 1, 'size': 16, 'same': True, 'NT': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 2, 'size': 1, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 5, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
grammar/sav/B11_Coverage.g4 | PSSTools/py-pss-parser | 1 | 2701 | /****************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
****************************************************************************/
grammar Coverage;
covergroup_declaration:
'covergroup' name=covergroup_identifier ('(' covergroup_port (',' covergroup_port)* ')')? '{'
covergroup_body_item*
'}'
;
covergroup_port:
data_type identifier
;
covergroup_body_item:
covergroup_option
| covergroup_coverpoint
| covergroup_cross
// >>= PSS 1.1
| ';'
// <<= PSS 1.1
;
covergroup_option:
'option' '.' identifier '=' constant_expression ';'
;
covergroup_instantiation:
covergroup_type_instantiation
| inline_covergroup
;
inline_covergroup:
'covergroup' '{'
covergroup_body_item*
'}' identifier ';'
;
covergroup_type_instantiation:
covergroup_type_identifier covergroup_identifier
'(' covergroup_portmap_list ')' ('with' '{' (covergroup_option)? '}')? ';'
;
covergroup_portmap_list:
(
(covergroup_portmap (',' covergroup_portmap)?)
| hierarchical_id_list
)
;
covergroup_portmap:
'.' identifier '(' hierarchical_id ')'
;
covergroup_coverpoint:
(data_type? coverpoint_identifier ':')? 'coverpoint' target=expression ('iff' '(' iff=expression ')')?
bins_or_empty
;
bins_or_empty:
('{' covergroup_coverpoint_body_item* '}' )
| ';'
;
covergroup_coverpoint_body_item:
covergroup_option
| covergroup_coverpoint_binspec
;
covergroup_coverpoint_binspec: (
(bins_keyword identifier (is_array='['constant_expression? ']')? '=' coverpoint_bins)
)
;
coverpoint_bins:
(
('[' covergroup_range_list ']' ('with' '(' covergroup_expression ')')? ';')
| (coverpoint_identifier 'with' '(' covergroup_expression ')' ';')
| is_default='default' ';'
)
;
covergroup_range_list:
covergroup_value_range (',' covergroup_value_range)*
;
covergroup_value_range:
expression
| (expression '..' expression?)
| (expression? '..' expression)
;
bins_keyword:
'bins'
| 'illegal_bins'
| 'ignore_bins'
;
covergroup_cross:
identifier ':' 'cross' coverpoint_identifier (',' coverpoint_identifier)*
('iff' '(' iff=expression ')')? cross_item_or_null
;
cross_item_or_null:
('{' covergroup_cross_body_item* '}' )
| ';'
;
covergroup_cross_body_item:
covergroup_option
| covergroup_cross_binspec
;
covergroup_cross_binspec:
bins_type=bins_keyword name=identifier
'=' covercross_identifier 'with' '(' expr=covergroup_expression ')' ';'
;
// TODO: no definition in the BNF
covergroup_expression:
expression
;
|
programs/oeis/010/A010931.asm | neoneye/loda | 22 | 19288 | <reponame>neoneye/loda
; A010931: Binomial coefficient C(15,n).
; 1,15,105,455,1365,3003,5005,6435,6435,5005,3003,1365,455,105,15,1
mov $1,15
bin $1,$0
mov $0,$1
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca.log_21829_1703.asm | ljhsiun2/medusa | 9 | 163476 | <reponame>ljhsiun2/medusa<filename>Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca.log_21829_1703.asm
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %r8
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0x54b9, %rsi
lea addresses_D_ht+0x120b8, %rdi
nop
nop
and $51120, %r8
mov $118, %rcx
rep movsw
cmp $14600, %rdi
lea addresses_A_ht+0x53b8, %rdi
nop
nop
nop
nop
xor %rax, %rax
mov $0x6162636465666768, %r11
movq %r11, %xmm3
movups %xmm3, (%rdi)
nop
nop
nop
nop
cmp %r8, %r8
lea addresses_WT_ht+0x17122, %r8
nop
nop
and $60791, %r14
movb $0x61, (%r8)
nop
nop
nop
and %rcx, %rcx
lea addresses_WT_ht+0x192b8, %rsi
lea addresses_WT_ht+0x1efe, %rdi
nop
nop
cmp %r12, %r12
mov $123, %rcx
rep movsl
nop
sub %rcx, %rcx
lea addresses_WT_ht+0x1a538, %rsi
nop
dec %rcx
movw $0x6162, (%rsi)
nop
nop
nop
nop
xor %r12, %r12
lea addresses_WC_ht+0x3e37, %rsi
lea addresses_D_ht+0x152b8, %rdi
nop
nop
nop
nop
nop
and %r8, %r8
mov $52, %rcx
rep movsb
sub %r8, %r8
lea addresses_A_ht+0x1b0b8, %rax
nop
nop
nop
nop
nop
add %rcx, %rcx
movb $0x61, (%rax)
nop
nop
nop
nop
nop
sub $25161, %r11
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r8
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r14
push %r15
push %rbp
push %rdi
push %rdx
// Store
lea addresses_US+0x60b8, %r12
nop
nop
nop
nop
nop
and $39801, %r13
mov $0x5152535455565758, %rdi
movq %rdi, (%r12)
nop
nop
nop
nop
nop
xor %rbp, %rbp
// Store
lea addresses_WC+0x1cd18, %rdx
nop
nop
nop
sub $33897, %r14
mov $0x5152535455565758, %r12
movq %r12, %xmm1
movups %xmm1, (%rdx)
nop
nop
add $40706, %rdi
// Faulty Load
lea addresses_D+0x158b8, %r15
nop
nop
nop
nop
xor $60138, %rbp
mov (%r15), %r14w
lea oracles, %rbp
and $0xff, %r14
shlq $12, %r14
mov (%rbp,%r14,1), %r14
pop %rdx
pop %rdi
pop %rbp
pop %r15
pop %r14
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 1, 'NT': False, 'type': 'addresses_D', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_US', 'same': False, 'AVXalign': False, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_WC', 'same': False, 'AVXalign': False, 'congruent': 3}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_D', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'same': True, 'type': 'addresses_WT_ht', 'congruent': 0}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 16, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 8}, 'dst': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 1}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_WT_ht', 'same': False, 'AVXalign': False, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 0}, 'dst': {'same': False, 'type': 'addresses_D_ht', 'congruent': 9}}
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': True, 'congruent': 11}}
{'36': 21829}
36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36 36
*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.