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 |
|---|---|---|---|---|
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/c9/c95040d.ada | best08618/asylo | 7 | 20092 | <gh_stars>1-10
-- C95040D.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 TASKING_ERROR IS RAISED IN A CALLING
-- TASK WHEN THE TASK OWNING THE ENTRY TERMINATES BEFORE RENDEZVOUS
-- CAN OCCUR.
-- CHECK THAT RE-RAISING TASKING_ERROR, ONCE TRAPPED IN THE CALLER,
-- DOES NOT PROPAGATE OUTSIDE THE TASK BODY.
-- GOM 11/29/84
-- JWC 05/14/85
-- PWB 02/11/86 CORRECTED CALL TO TEST TO SHOW CORRECT TEST NAME.
-- RLB 12/15/99 REMOVED POTENTIALLY ERRONEOUS CALLS TO REPORT.COMMENT.
WITH REPORT;
USE REPORT;
PROCEDURE C95040D IS
PROCEDURE DRIVER IS
TASK NEST IS
ENTRY OUTER;
ENTRY INNER;
END NEST;
TASK SLAVE;
TASK BODY NEST IS
BEGIN
--COMMENT("AT TOP OF 'NEST' TASK WAITING ON 'OUTER' " &
-- "RENDEZVOUS");
ACCEPT OUTER DO
--COMMENT("IN 'OUTER' RENDEZVOUS OF 'NEST' TASK " &
-- "ABOUT TO 'RETURN'");
RETURN; -- CAUSES 'INNER' RENDEZVOUS TO BE SKIPPED.
ACCEPT INNER DO
FAILED("'INNER' RENDEZVOUS OF 'NEST' TASK " &
"SHOULD NEVER BE PERFORMED");
END INNER;
END OUTER;
--COMMENT("'OUTER' RENDEZVOUS COMPLETED IN 'NEST' TASK " &
-- "AND NOW TERMINATING");
END NEST;
TASK BODY SLAVE IS
BEGIN
--COMMENT("AT TOP OF 'SLAVE' TASK. CALLING 'INNER' " &
-- "RENDEZVOUS");
NEST.INNER;
FAILED("SHOULD HAVE RAISED 'TASKING_ERROR' IN 'SLAVE' " &
"TASK");
EXCEPTION
WHEN TASKING_ERROR =>
--COMMENT("'SLAVE' TASK CORRECTLY TRAPPING " &
-- "'TASKING_ERROR' AND RE-RAISING IT (BUT " &
-- "SHOULD NOT BE PROPAGATED)");
RAISE;
END SLAVE;
BEGIN -- START OF DRIVER PROCEDURE.
--COMMENT("AT TOP OF 'DRIVER'. CALLING 'OUTER' ENTRY OF " &
-- "'NEST' TASK");
NEST.OUTER;
--COMMENT("'OUTER' RENDEZVOUS COMPLETED. 'DRIVER' AWAITING " &
-- "TERMINATION OF 'NEST' AND 'SLAVE' TASKS");
EXCEPTION
WHEN TASKING_ERROR =>
FAILED("'TASKING_ERROR' CAUGHT IN 'DRIVER' WHEN IT " &
"SHOULD HAVE BEEN CAUGHT IN 'SLAVE' TASK, OR " &
"'TASKING_ERROR' WAS INCORRECTLY PROPAGATED BY " &
"'SLAVE' TASK");
END DRIVER;
BEGIN -- START OF MAIN PROGRAM.
TEST("C95040D","CHECK THAT 'TASKING_ERROR' IS RAISED IN A " &
"CALLER TASK WHEN TASK OWNING THE ENTRY CANNOT " &
"PERFORM RENDEZVOUS. ALSO CHECK THAT " &
"'TASKING_ERROR', ONCE RAISED, IS NOT PROPAGATED " &
"OUTSIDE THE TASK BODY");
--COMMENT("MAIN PROGRAM CALLING 'DRIVER' PROCEDURE");
DRIVER;
--COMMENT("MAIN PROGRAM NOW TERMINATING");
RESULT;
END C95040D;
|
alloy4fun_models/trashltl/models/9/APXk6QJ8r7taDnx35.als | Kaixi26/org.alloytools.alloy | 0 | 2041 | <filename>alloy4fun_models/trashltl/models/9/APXk6QJ8r7taDnx35.als
open main
pred idAPXk6QJ8r7taDnx35_prop10 {
always all f:File | once f in Protected && always f in Protected
}
pred __repair { idAPXk6QJ8r7taDnx35_prop10 }
check __repair { idAPXk6QJ8r7taDnx35_prop10 <=> prop10o } |
programs/oeis/169/A169695.asm | neoneye/loda | 22 | 175255 | ; A169695: a(n) = 1 if n is a square, otherwise a(n) = 2.
; 1,1,2,2,1,2,2,2,2,1,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2
lpb $0
add $2,2
sub $0,$2
trn $0,1
mov $1,$0
cmp $1,0
add $0,$1
lpe
add $1,1
mov $0,$1
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/specs/static_initializer5.ads | best08618/asylo | 7 | 29740 | -- { dg-do compile }
with Static_Initializer5_Pkg; use Static_Initializer5_Pkg;
package Static_Initializer5 is
type Derived is new Rec with record
Target : Boolean;
end record;
Null_Derived : constant Derived := (Null_Rec with Target => False);
end Static_Initializer5;
|
archive/agda-3/src/Oscar/Data/Substitunction.agda | m0davis/oscar | 0 | 8139 |
open import Oscar.Prelude
open import Oscar.Data.¶
open import Oscar.Data.Fin
open import Oscar.Data.Term
module Oscar.Data.Substitunction where
module Substitunction {𝔭} (𝔓 : Ø 𝔭) where
open Term 𝔓
Substitunction : ¶ → ¶ → Ø 𝔭
Substitunction m n = ¶⟨< m ⟩ → Term n
module SubstitunctionOperator {𝔭} (𝔓 : Ø 𝔭) where
open Substitunction 𝔓
_⊸_ = Substitunction
|
programs/oeis/168/A168123.asm | karttu/loda | 1 | 242910 | ; A168123: n^2*(n^5+1)/2.
; 0,1,66,1098,8200,39075,139986,411796,1048608,2391525,5000050,9743646,17915976,31374343,52706850,85429800,134217856,205169481,306110178,446936050,640000200,900544491,1247179186,1702412988,2293236000,3051758125,4015905426,5230176966,6746464648,8624938575,10935000450,13756307536,17179869696,21309222033,26261675650,32169649050,39182082696,47465939251,57207792018,68615504100,81920000800,97377137781,115269667506,135909306478,159638905800,186834727575,217908829666,253311561336,293534172288,339111537625,390625001250,448705340226,514035852616,587355571323,669462606450,761217618700,863547426336,977448748221,1103992085458,1244325744150,1399680001800,1571371419871,1760807305026,1969490321568,2199023257600,2451113947425,2727580352706,3030355804906,3361494411528,3723176628675,4117715002450,4547560081716,5015306504736,5523699262213,6075640139250,6674194338750,7322597288776,8024261636391,8782784430498,9601954496200,10485760003200,11438396230761,12464273531746,13568025498258,14754517331400,16028854417675,17396391114546,18862739747676,20433779822368,22115667451725,23914845004050,25838050972006,27892330066056,30085043534703,32423879714050,34916864809200,37572373910016,40399142243761,43406276667138,46603267400250,50000000005000,53606767610451,57434283387666,61493693276548,65796588967200,70355021138325,75181512955186,80289073829646,85691213444808,91401956046775,97435855006050,103808007651096,110534070376576,117630274028793,125113439570850,133000994030050,141310986730056,150062105810331,159273695035378,168965770896300,179159040007200,189874916798941,201135541512786,212963798496438,225383334805000,238418579109375,252094760914626,266437930090816,281474976718848,297233651253825,313742585008450,331031310958986,349130284876296,368070906784483,387885542749650,408607547001300,430271284388896,452912153176101,476566608175218,501272184224350,527067520009800,553992382236231,582087690147106,611395540397928,641959232284800,673823293330825,707033505232866,741636930171186,777681937484488,815218230712875,854296875011250,894970324935676,937292452605216,981318576241773,1027105489090450,1074711488722950,1124196406726536,1175621638781071,1229050175126658,1284546631424400,1342177280012800,1402010081562321,1464114717130626,1528562620621018,1595427011646600,1664782928802675,1736707263349906,1811278793310756,1888578217981728,1968688192863925,2051693365014450,2137680408821166,2226738062203336,2318957163240663,2414430687233250,2513253784195000,2615523816782976,2721340398665241,2830805433329698,2944023153336450,3061100160016200,3182145463617211,3307270523903346,3436589291205708,3570218247930400,3708276450524925,3850885571905746,3998169944349526,4150256602850568,4307275328946975,4469358695018050,4636642109055456,4809263859910656,4987365163021153,5171090206618050,5360586198417450,5556003412798216,5757495238468611,5965218226624338,6179332139600500,6400000000020000,6627388140440901,6861666253505266,7103007442591998,7351588272976200,7607588823497575,7871192738740386,8142587281727496,8421963387131008,8709515715002025,9005442705022050
mov $1,$0
pow $0,7
pow $1,2
add $1,$0
div $1,2
|
process_an_image.asm | elifBalci/image-classification-on-mips | 2 | 28126 | <gh_stars>1-10
.eqv BMP_FILE_SIZE 120054 #change for 200*200 images
.eqv BYTES_PER_ROW 600
.data
#space for the 600x50px 24-bits bmp image
.align 4
res: .space 2
image: .space BMP_FILE_SIZE
list: .space 8160 #32 * 255
modeList: .word 2, 8, 10, 12, 58, 63, 65, 69, 72, 75, 76, 91 # those are mode values of several pictures of steak, salam and cur.fist four is for cur then ste then sal
file_name: .asciiz "ste-04.bmp"
cur: .asciiz "cur"
sal: .asciiz "sal"
ste: .asciiz "ste"
file_type_error: .asciiz "file is not in bmp format. Program will end immediately."
new_line: .asciiz "\n"
list_size: .word 255
mode_list_size: .word 12
.text
main:
la $a0, file_name #|read image
jal read_bmp #| args: $a0 - file name
li $a0, 0 #|
jal get_color #|cretae histogram
# args: $t1- list size , $t0 - list , $t2-0, $t3 -0
li $t4, 0 #|
li $t3, 0 #|
li $t2, 0 #|
lw $t1, list_size #|
la $t0, list #| find mode
jal find_mode # $t4 will be the used
li $t3, 0
li $t2, 0
la $t0, modeList
jal compare_image # args: $t0 - list, $t2- 0, $t3-0, $t4 0
sub $a0, $a0, $a0
add $a0, $a0, $t2
jal identify_image
li $v0, 10 #|
syscall #|end program
#__________________________________________________________________________
read_bmp: # args: $a0 - file name
#reads the contents of a bmp file into memory
#no args, no return value
sub $sp, $sp, 4 #push $ra to the stack
sw $ra,4($sp)
sub $sp, $sp, 4 #push $s1
sw $s1, 4($sp)
#open file
#la $a0, file_name #file name
li $a1, 0 #flags: 0-read file
li $a2, 0 #mode: ignored
li $v0, 13 #open file
syscall
move $s1, $v0 # save the file descriptor
#read file
move $a0, $s1
la $a1, image
li $a2, BMP_FILE_SIZE
li $v0, 14 #read from file
syscall
#check if it is a bmp file
# It must be 'B, M' (42, 4D) in dec 66 and 77
la $t0, image
lbu $t1, ($t0)
li $t2, 66 #check if first char is B
bne $t1, $t2, exit_program
la $t0, image + 1
lbu $t1, ($t0)
li $t2, 77 #check if second char is M
bne $t1, $t2, exit_program
#close file
li $v0, 16
move $a0, $s1
syscall
lw $s1, 4($sp) #restore (pop) $s1
add $sp, $sp, 4
lw $ra, 4($sp) #restore (pop) $ra
add $sp, $sp, 4
jr $ra
exit_program:
la $a0, file_type_error #|
li $v0, 4 #|
syscall #|print file_type_error string
li $v0, 10 #|
syscall #|end program
# ============================================================================
get_color:
sub $sp, $sp, 4 #push $ra to the stack
sw $ra,4($sp)
la $t1, image + 10 #adress of file offset to pixel array
lw $t2, ($t1) #file offset to pixel array in $t2
li $t5, BMP_FILE_SIZE
sub $t5, $t5, $t2 # |how many green values are there
div $t5, $t5, 3 # |how many green values are there
la $t1, image #adress of bitmap
add $t2, $t1, $t2 #adress of pixel array in $t2
#fill the array with green values
add $t2, $t2, 1 #first green
li $t3, 0 # $t3 is the counter of loop
li $t4, 0
loop_through_pixels:
beq $t3, $t5, get_color_end
la $t6, list # $t6 = array address
mul $t4, $t3, 3 # $t4 = 3* $t3
add $t4, $t2, $t4 # $t4 = $t4 + $t2
lb $t1,($t4) # load G
#save to array
#sb $t1, ($t6)
#add $t6, $t6, 4
#inc array
mul $t1, $t1, 4 #or 4
add $t6, $t6, $t1
lw $t7, ($t6)
addi $t7, $t7, 1
sw $t7, ($t6)
add $t3, $t3, 1
j loop_through_pixels
get_color_end:
lw $ra, 4($sp) #restore (pop) $ra
add $sp, $sp, 4
jr $ra
# ============================================================================
# args: $t3 - list size , $t2 - 0, $t1 - list
print_array: # print array content
beq $t2, 255, print_done#check for array end
lw $a0, ($t1) #print list element
li $v0, 1
syscall
la $a0, new_line # print a newline
li $v0, 4
syscall
add $t2, $t2, 1 # advance loop counter
add $t1, $t1, 4 # advance array pointer
b print_array # repeat the loop
print_done:
la $a0, new_line # takes address of string via $a0
li $v0, 4 # takes
syscall # via register $v0 syscall
jr $ra
#____________________________________________________________________________________#
find_mode:# tis function finds the most occuring number from the array
# args: $t1- list size , $t0 - list, $t2- 0, $t3-0, $t4 0
#t3 is for max value
#t4 for identify which one it is
li $t4, 0
li $t3, 0
li $t2, 0
loop:
beq $t2, 255, find_mode_done # check for array end
lw $a0, ($t0)
bge $a0, $t3, greater
add $t2, $t2, 1 # advance loop counter
add $t0, $t0, 4 # advance array pointer
b loop # repeat the loop
greater:
li $t4, 0 #|
add $t4, $t4, $t2 #| t4 = t2
li $t3,0 #|
add $t3, $a0, $t3 #| t3 = a0
add $t2, $t2, 1 # advance loop counter
add $t0, $t0, 4 # advance array pointer
j loop
find_mode_done:
jr $ra
#____________________________________________________________________________________#
compare_image: # args: , $t0 - list, $t2- 0, $t3-0, $t4 0 #return t2
la $a1, mode_list_size
lw $a2, ($a1)
compare_loop:
beq $t2, $a2, compare_image_done # check for array end
lw $a0, ($t0)
bge $a0, $t4, compare_image_done
#bge $a0, $t4, compare_image_done
add $t2, $t2, 1 # advance loop counter
add $t0, $t0, 4 # advance array pointer
b compare_loop # repeat the loop
compare_image_done:
jr $ra
#____________________________________________________________________________________#
identify_image: #a0- value
sub $sp, $sp, 4 #push $ra to the stack
sw $ra,4($sp)
indentify_loop:
li $t0, 3
bge $t0, $a0, print_cur
li $t0, 7
bge $t0, $a0, print_ste
li $t0, 11
bge $t0, $a0, print_sal
print_cur:
la $a0, cur
li $v0, 4
syscall
b identify_image_exit
print_ste:
la $a0, ste
li $v0, 4
syscall
j identify_image_exit
print_sal:
la $a0, sal
li $v0, 4
syscall
b identify_image_exit
identify_image_exit:
lw $ra, 4($sp) #restore (pop) $ra
add $sp, $sp, 4
jr $ra
#____________________________________________________________________________________#
|
Info/VecAddSSE.asm | PhilippMueller1991/SIMD_Tests | 0 | 23539 | <filename>Info/VecAddSSE.asm
; ============================================================================================= C++ implementation
;void VecAddSSE(Vec4f& out, const Vec4f& A, const Vec4f& B)
;{
; out.row = _mm_add_ps(A.row, B.row);
;}
; ============================================================================================= DEBUG x64
; 21 : out.row = _mm_add_ps(A.row, B.row);
mov rax, QWORD PTR A$[rbp]
mov rcx, QWORD PTR B$[rbp]
movups xmm0, XMMWORD PTR [rax]
addps xmm0, XMMWORD PTR [rcx]
movaps XMMWORD PTR $T1[rbp], xmm0
mov rax, QWORD PTR out$[rbp]
movaps xmm0, XMMWORD PTR $T1[rbp]
movups XMMWORD PTR [rax], xmm0
; ============================================================================================= RELEASE x64
; 21 : out.row = _mm_add_ps(A.row, B.row);
movups xmm0, XMMWORD PTR [rdx]
addps xmm0, XMMWORD PTR [r8]
movups XMMWORD PTR [rcx], xmm0 |
oeis/348/A348589.asm | neoneye/loda-programs | 11 | 165647 | ; A348589: a(n) = (10^n+2)^2 / 6.
; Submitted by <NAME>(s4)
; 24,1734,167334,16673334,1666733334,166667333334,16666673333334,1666666733333334,166666667333333334,16666666673333333334,1666666666733333333334,166666666667333333333334,16666666666673333333333334,1666666666666733333333333334
mov $1,10
pow $1,$0
mul $1,20
add $1,6
div $1,6
pow $1,2
mov $0,$1
div $0,4
mul $0,6
|
programs/oeis/089/A089186.asm | neoneye/loda | 22 | 29124 | ; A089186: Decreases from 9 * 10^k down to 1, restarting at 9 * 10^(k+1).
; 9,8,7,6,5,4,3,2,1,90,89,88,87,86,85,84,83,82,81,80,79,78,77,76,75,74,73,72,71,70,69,68,67,66,65,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28
add $0,1
seq $0,178914 ; 10's complement of nonnegative numbers.
|
programs/oeis/250/A250762.asm | jmorken/loda | 1 | 160640 | <reponame>jmorken/loda
; A250762: Number of (7+1) X (n+1) 0..2 arrays with nondecreasing x(i,j)-x(i,j-1) in the i direction and nondecreasing x(i,j)+x(i-1,j) in the j direction.
; 29012,67356,121593,191723,277746,379662,497471,631173,780768,946256,1127637,1324911,1538078,1767138,2012091,2272937,2549676,2842308,3150833,3475251,3815562,4171766,4543863,4931853,5335736,5755512,6191181,6642743
mov $14,$0
mov $16,$0
add $16,1
lpb $16
clr $0,14
mov $0,$14
sub $16,1
sub $0,$16
mov $11,$0
mov $13,$0
add $13,1
lpb $13
mov $0,$11
sub $13,1
sub $0,$13
mov $7,$0
mov $9,2
lpb $9
mov $0,$7
sub $9,1
add $0,$9
sub $0,1
trn $0,1
mov $4,3
add $4,$0
mov $5,27
mul $5,$4
mul $5,81
sub $5,1
mov $1,$5
mov $10,$9
lpb $10
mov $8,$1
sub $10,1
lpe
lpe
lpb $7
mov $7,0
sub $8,$1
lpe
mov $1,$8
mul $1,3
add $1,9332
add $12,$1
lpe
add $15,$12
lpe
mov $1,$15
|
alloy4fun_models/trashltl/models/17/D3hggGGtTwqjyYA6H.als | Kaixi26/org.alloytools.alloy | 0 | 2588 | open main
pred idD3hggGGtTwqjyYA6H_prop18 {
always (all f : File | f in Protected until f in Trash)
}
pred __repair { idD3hggGGtTwqjyYA6H_prop18 }
check __repair { idD3hggGGtTwqjyYA6H_prop18 <=> prop18o } |
8-1-backup/8-1.asm | ParkinWu/x86_asm_exercise | 0 | 16110 | <reponame>ParkinWu/x86_asm_exercise<gh_stars>0
app_lba_start equ 100
SECTION mbr align=16 vstart=0x7c00
mov ax, 0
mov ss, ax
mov sp, ax
mov ax, [cs:phy_base]
mov dx, [cs:phy_base+0x02]
mov bx, 16
div bx
mov ds, ax
mov es, ax
phy_base dd 0x10000
times 510-($-$$) db 0
db 0x55, 0xaa
|
Transynther/x86/_processed/AVXALIGN/_zr_/i9-9900K_12_0xa0.log_2_1407.asm | ljhsiun2/medusa | 9 | 103599 | <filename>Transynther/x86/_processed/AVXALIGN/_zr_/i9-9900K_12_0xa0.log_2_1407.asm
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r14
push %r15
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0x4cdd, %r15
nop
nop
cmp %rax, %rax
mov $0x6162636465666768, %rbx
movq %rbx, %xmm6
vmovups %ymm6, (%r15)
nop
nop
xor $46353, %rax
lea addresses_WT_ht+0x1f5d, %r14
nop
sub $23592, %rbp
mov $0x6162636465666768, %rcx
movq %rcx, (%r14)
nop
nop
nop
nop
nop
add $548, %rbx
lea addresses_A_ht+0x188dd, %r15
nop
nop
and $7036, %r10
mov $0x6162636465666768, %rcx
movq %rcx, %xmm3
movups %xmm3, (%r15)
nop
sub %r15, %r15
lea addresses_WT_ht+0x1e53d, %r10
nop
nop
xor %r15, %r15
mov (%r10), %ecx
nop
nop
and %rbx, %rbx
lea addresses_UC_ht+0xa49d, %rbp
nop
nop
add %rax, %rax
mov (%rbp), %rcx
nop
nop
nop
nop
nop
and $8416, %rax
lea addresses_D_ht+0x6ab5, %r15
nop
and $52594, %rbx
movl $0x61626364, (%r15)
nop
nop
and %r15, %r15
lea addresses_D_ht+0xbf5d, %r14
nop
nop
nop
sub $46277, %rcx
movb $0x61, (%r14)
nop
nop
nop
and $34361, %rax
lea addresses_WT_ht+0xe5dd, %rsi
lea addresses_WT_ht+0x5c9d, %rdi
nop
and $41594, %rbx
mov $95, %rcx
rep movsw
nop
nop
nop
inc %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r15
pop %r14
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r14
push %rax
push %rbp
push %rcx
push %rdx
// Store
lea addresses_A+0x121f5, %rax
add $35637, %rdx
mov $0x5152535455565758, %rbp
movq %rbp, (%rax)
nop
nop
nop
nop
sub %rbp, %rbp
// Store
lea addresses_WT+0x19ddd, %rcx
nop
nop
nop
add $42899, %rbp
movw $0x5152, (%rcx)
nop
nop
nop
nop
dec %rax
// Store
lea addresses_normal+0x35dd, %r11
nop
nop
and $41716, %r14
movb $0x51, (%r11)
nop
nop
nop
add $5158, %r14
// Load
lea addresses_US+0x1b1fd, %rdx
nop
nop
nop
nop
nop
cmp %rax, %rax
movups (%rdx), %xmm0
vpextrq $1, %xmm0, %r11
nop
nop
nop
add %rdx, %rdx
// Store
lea addresses_UC+0x124dd, %r12
nop
nop
add $15279, %rcx
movw $0x5152, (%r12)
nop
nop
and %r12, %r12
// Store
lea addresses_UC+0x4cb9, %rdx
add %r11, %r11
mov $0x5152535455565758, %rcx
movq %rcx, %xmm4
vmovups %ymm4, (%rdx)
nop
nop
nop
nop
nop
cmp %rcx, %rcx
// Store
lea addresses_WC+0x164dd, %r14
nop
nop
nop
xor $50397, %r11
mov $0x5152535455565758, %rcx
movq %rcx, (%r14)
nop
nop
nop
nop
nop
sub $37631, %r12
// Store
lea addresses_RW+0x847d, %r14
dec %r12
mov $0x5152535455565758, %rcx
movq %rcx, %xmm2
vmovups %ymm2, (%r14)
nop
nop
nop
nop
nop
and $59872, %rbp
// Store
lea addresses_PSE+0x6b1d, %rax
nop
nop
nop
nop
sub %rcx, %rcx
mov $0x5152535455565758, %r14
movq %r14, %xmm3
vmovntdq %ymm3, (%rax)
nop
nop
sub %rbp, %rbp
// Faulty Load
lea addresses_PSE+0x194dd, %r14
nop
nop
nop
and %rax, %rax
vmovntdqa (%r14), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $1, %xmm0, %rcx
lea oracles, %rax
and $0xff, %rcx
shlq $12, %rcx
mov (%rax,%rcx,1), %rcx
pop %rdx
pop %rcx
pop %rbp
pop %rax
pop %r14
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_PSE', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_A', 'AVXalign': False, 'size': 8}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_WT', 'AVXalign': True, 'size': 2}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 8, 'type': 'addresses_normal', 'AVXalign': False, 'size': 1}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_US', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 11, 'type': 'addresses_UC', 'AVXalign': True, 'size': 2}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_UC', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 10, 'type': 'addresses_WC', 'AVXalign': False, 'size': 8}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_RW', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': True, 'same': False, 'congruent': 6, 'type': 'addresses_PSE', 'AVXalign': False, 'size': 32}}
[Faulty Load]
{'src': {'NT': True, 'same': True, 'congruent': 0, 'type': 'addresses_PSE', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 11, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_WT_ht', 'AVXalign': True, 'size': 8}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 9, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 16}}
{'src': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': True, 'congruent': 1, 'type': 'addresses_UC_ht', 'AVXalign': True, 'size': 8}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 4}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 6, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 1}}
{'src': {'same': False, 'congruent': 8, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 6, 'type': 'addresses_WT_ht'}}
{'00': 2}
00 00
*/
|
models/amalgam/tests/test_comprehension.als | transclosure/Amalgam | 4 | 3271 | sig Node {edges : set Node }
fact testComprehensionExpansion {
some { n1, n2: Node | n1->n2 in edges}
lone edges
}
// Ask why the lone edge is necessary
run {} for exactly 2 Node
|
examples/Miller/Pat.agda | cruhland/agda | 1,989 | 14050 | <reponame>cruhland/agda
module Pat (BaseType : Set) where
data Ty : Set where
ι : BaseType -> Ty
_⟶_ : Ty -> Ty -> Ty
data Bwd (A : Set) : Set where
• : Bwd A
_◄_ : Bwd A -> A -> Bwd A
infixl 30 _◄_
Ctx = Bwd Ty
data Take {A : Set} : Bwd A -> A -> Bwd A -> Set where
hd : forall {x xs} -> Take (xs ◄ x) x xs
tl : forall {x y xs ys} -> Take xs x ys -> Take (xs ◄ y) x (ys ◄ y)
data Pat : Ctx -> Ctx -> Ty -> Ctx -> Set
data Pats : Ctx -> Ty -> Ctx -> Ty -> Set where
ε : forall {Θ τ} -> Pats Θ τ Θ τ
_,_ : forall {Θ₁ Θ₂ Θ₃ ρ σ τ} ->
Pat • Θ₁ ρ Θ₂ -> Pats Θ₂ σ Θ₃ τ ->
Pats Θ₁ (ρ ⟶ σ) Θ₃ τ
data Pat where
ƛ : forall {Δ Θ Θ' σ τ} -> Pat (Δ ◄ σ) Θ τ Θ' ->
Pat Δ Θ (σ ⟶ τ) Θ'
_[_] : forall {Θ Θ' Δ σ τ} ->
Take Θ σ Θ' -> Pats Δ σ • τ -> Pat Δ Θ τ Θ'
|
oeis/350/A350361.asm | neoneye/loda-programs | 11 | 103638 | <reponame>neoneye/loda-programs<gh_stars>10-100
; A350361: 2-tone chromatic number of a tree with maximum degree n.
; Submitted by <NAME>
; 4,5,5,6,6,6,7,7,7,7,8,8,8,8,8,9,9,9,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,15,15,15,15,15
lpb $0
add $2,1
sub $0,$2
lpe
mov $0,$2
add $0,4
|
tools/dumpers/lfont_dmp.asm | Iambian/VANISH | 1 | 21381 | <filename>tools/dumpers/lfont_dmp.asm
.db $07,$52,$03,$33,$50,$98,$49,$80,$40,$96,$49,$89,$92,$72,$00,$20 ; 0000
.db $91,$51,$11,$13,$4D,$80,$40,$91,$51,$8A,$8A,$64,$80,$40,$11,$11 ; 0010
.db $55,$95,$4A,$80,$48,$8C,$4E,$8C,$88,$60,$84,$0E,$1F,$2E,$4E,$80 ; 0020
.db $40,$80,$40,$8E,$CE,$9F,$4E,$64,$02,$45,$04,$24,$44,$94,$48,$80 ; 0030
.db $51,$8A,$C4,$8A,$51,$60,$00,$20,$80,$4E,$0A,$0E,$40,$80,$40,$80 ; 0040
.db $C4,$8E,$44,$60,$80,$40,$00,$00,$44,$80,$40,$80,$40,$80,$DC,$88 ; 0050
.db $48,$68,$8C,$62,$4C,$82,$0C,$80,$40,$9F,$98,$78,$1E,$38,$18,$F8 ; 0060
.db $07,$04,$04,$04,$94,$6C,$04,$83,$41,$99,$81,$61,$00,$E0,$4C,$22 ; 0070
.db $84,$48,$4E,$80,$40,$C0,$40,$A1,$C2,$84,$48,$9F,$4C,$32,$92,$4C ; 0080
.db $00,$00,$80,$B6,$58,$D0,$50,$80,$40,$80,$4E,$04,$84,$04,$04,$20 ; 0090
.db $00,$01,$06,$18,$06,$01,$00,$1F,$02,$82,$1F,$44,$1F,$28,$08,$10 ; 00A0
.db $0C,$03,$0C,$10,$00,$1F,$00,$00,$87,$40,$00,$00,$00,$00,$00,$0F ; 00B0
.db $08,$0E,$08,$0F,$00,$24,$02,$1F,$02,$24,$00,$40,$00,$97,$55,$95 ; 00C0
.db $95,$77,$04,$2E,$15,$24,$04,$04,$04,$24,$04,$24,$04,$35,$0E,$24 ; 00D0
.db $00,$00,$00,$00,$40,$60,$80,$84,$84,$84,$84,$80,$44,$64,$8A,$2A ; 00E0
.db $4A,$40,$40,$40,$80,$6A,$4A,$5F,$4A,$5F,$8A,$AA,$08,$0A,$0E,$02 ; 00F0
.db $42,$40,$40,$B8,$99,$02,$84,$08,$93,$03,$08,$14,$14,$08,$15,$12 ; 0100
.db $0D,$24,$84,$44,$40,$80,$C0,$E0,$82,$24,$08,$48,$08,$24,$82,$08 ; 0110
.db $C4,$62,$42,$82,$84,$68,$00,$04,$15,$0E,$95,$64,$00,$80,$84,$E4 ; 0120
.db $1F,$84,$84,$60,$80,$20,$00,$20,$0C,$24,$08,$20,$00,$20,$1F,$20 ; 0130
.db $80,$20,$00,$00,$00,$40,$00,$2C,$8C,$00,$81,$22,$44,$48,$50,$80 ; 0140
.db $0E,$11,$13,$15,$99,$91,$8E,$84,$8C,$84,$44,$E4,$04,$8E,$0E,$11 ; 0150
.db $01,$02,$C4,$E8,$9F,$5F,$82,$44,$82,$41,$D1,$8E,$02,$06,$8A,$32 ; 0160
.db $5F,$42,$42,$5F,$90,$7E,$01,$41,$11,$8E,$C6,$E8,$10,$5E,$11,$31 ; 0170
.db $8E,$1F,$01,$22,$04,$48,$C8,$E8,$0E,$11,$11,$0E,$D1,$71,$8E,$8E ; 0180
.db $91,$91,$8F,$81,$02,$6C,$00,$0C,$0C,$00,$CC,$6C,$00,$A0,$0C,$2C ; 0190
.db $40,$2C,$84,$08,$02,$24,$08,$30,$88,$64,$42,$A0,$80,$7F,$00,$3F ; 01A0
.db $00,$20,$88,$64,$42,$81,$42,$84,$48,$8E,$91,$41,$82,$44,$C0,$C4 ; 01B0
.db $CE,$F1,$15,$17,$54,$90,$8F,$4E,$11,$31,$9F,$51,$51,$91,$DE,$F1 ; 01C0
.db $11,$1E,$51,$91,$5E,$8E,$D1,$70,$50,$10,$91,$6E,$5E,$31,$91,$11 ; 01D0
.db $51,$31,$1E,$1F,$10,$10,$1E,$10,$10,$1F,$1F,$10,$10,$1E,$10,$10 ; 01E0
.db $10,$0E,$11,$10,$17,$11,$51,$AF,$11,$11,$91,$1F,$91,$31,$91,$6E ; 01F0
.db $84,$24,$84,$04,$04,$0E,$07,$02,$02,$02,$02,$F2,$0C,$F1,$12,$F4 ; 0200
.db $18,$14,$12,$11,$90,$10,$90,$10,$90,$10,$1F,$31,$1B,$55,$15,$51 ; 0210
.db $11,$51,$11,$11,$19,$15,$13,$11,$91,$6E,$11,$11,$11,$11,$11,$0E ; 0220
.db $9E,$71,$91,$1E,$90,$70,$10,$4E,$91,$71,$11,$15,$12,$0D,$9E,$71 ; 0230
.db $91,$5E,$94,$72,$11,$0F,$10,$10,$0E,$01,$01,$1E,$1F,$64,$84,$04 ; 0240
.db $04,$24,$84,$11,$11,$71,$11,$11,$11,$0E,$11,$11,$11,$11,$0A,$0A ; 0250
.db $04,$11,$11,$11,$15,$15,$15,$0A,$11,$51,$0A,$04,$0A,$D1,$11,$51 ; 0260
.db $11,$51,$8A,$44,$04,$24,$1F,$21,$82,$44,$88,$F0,$5F,$86,$89,$F1 ; 0270
.db $1F,$91,$12,$8C,$00,$90,$48,$44,$82,$41,$00,$2C,$84,$44,$84,$84 ; 0280
.db $44,$0C,$C4,$EA,$51,$80,$00,$A0,$00,$E0,$00,$A0,$00,$80,$00,$9F ; 0290
.db $04,$04,$02,$00,$80,$60,$40,$80,$80,$EE,$01,$8F,$11,$6F,$10,$10 ; 02A0
.db $16,$19,$11,$31,$1E,$20,$00,$2E,$10,$30,$D1,$2E,$41,$81,$4D,$D3 ; 02B0
.db $51,$F1,$CF,$E0,$C0,$AE,$D1,$9F,$50,$8E,$06,$A9,$88,$5C,$48,$28 ; 02C0
.db $48,$20,$4F,$31,$91,$4F,$01,$AE,$10,$10,$16,$59,$11,$F1,$91,$E4 ; 02D0
.db $00,$EC,$04,$44,$04,$0E,$C2,$E0,$C6,$E2,$C2,$F2,$CC,$E8,$C8,$E9 ; 02E0
.db $CA,$EC,$CA,$E9,$CC,$E4,$C4,$C4,$44,$84,$8E,$40,$C0,$DA,$D5,$D5 ; 02F0
.db $D1,$D1,$C0,$E0,$D6,$D9,$51,$B1,$51,$80,$40,$AE,$51,$B1,$D1,$EE ; 0300
.db $C0,$E0,$DE,$D1,$5E,$F0,$50,$C0,$40,$AD,$53,$CF,$C1,$E1,$00,$00 ; 0310
.db $16,$19,$10,$10,$10,$00,$00,$0E,$10,$0E,$C1,$FE,$08,$28,$9C,$68 ; 0320
.db $48,$A9,$06,$20,$00,$31,$11,$11,$D3,$ED,$00,$20,$91,$51,$91,$6A ; 0330
.db $84,$40,$80,$51,$11,$15,$D5,$EA,$00,$20,$91,$0A,$84,$2A,$91,$40 ; 0340
.db $80,$31,$11,$0F,$C1,$EE,$00,$00,$1F,$02,$04,$48,$1F,$23,$84,$04 ; 0350
.db $48,$04,$04,$03,$04,$C4,$04,$E4,$84,$64,$C4,$38,$C4,$04,$42,$04 ; 0360
.db $04,$18,$C0,$E8,$D5,$62,$C0,$20,$C0,$1F,$5F,$11,$1F,$11,$1F,$1F ; 0370
.db $00,$00,$0E,$0A,$0A,$8A,$0E,$C0,$00,$E4,$8C,$E4,$C4,$E4,$00,$00 ; 0380
.db $8C,$02,$44,$28,$4E,$E0,$40,$2C,$82,$04,$02,$0C,$00,$00,$08,$2A ; 0390
.db $8E,$42,$82,$40,$80,$4E,$08,$2C,$02,$0C,$00,$00,$06,$88,$0E,$0A ; 03A0
.db $0E,$20,$00,$0E,$42,$04,$08,$08,$00,$20,$8E,$6A,$CE,$EA,$8E,$60 ; 03B0
.db $80,$6E,$8A,$6E,$02,$0C,$02,$04,$8E,$71,$91,$7F,$91,$68,$C4,$EE ; 03C0
.db $91,$71,$1F,$31,$44,$AA,$80,$4E,$51,$BF,$91,$4A,$40,$AE,$91,$51 ; 03D0
.db $5F,$B1,$02,$24,$CE,$61,$0F,$B1,$8F,$68,$44,$2E,$81,$EF,$11,$2F ; 03E0
.db $04,$2A,$8E,$61,$CF,$F1,$8F,$6A,$80,$6E,$01,$0F,$11,$0F,$02,$64 ; 03F0
.db $9F,$90,$9E,$90,$9F,$A8,$44,$9F,$50,$9E,$90,$BF,$04,$0A,$1F,$10 ; 0400
.db $1E,$10,$1F,$0A,$00,$1F,$10,$1E,$10,$1F,$02,$04,$0E,$11,$1F,$10 ; 0410
.db $0E,$08,$04,$0E,$11,$1F,$10,$0E,$04,$0A,$0E,$11,$1F,$10,$0E,$0A ; 0420
.db $00,$0E,$11,$1F,$10,$0E,$02,$04,$0E,$04,$04,$04,$0E,$08,$04,$0E ; 0430
.db $04,$04,$04,$0E,$04,$0A,$0E,$04,$04,$04,$0E,$0A,$00,$0E,$04,$04 ; 0440
.db $04,$0E,$02,$04,$00,$0C,$04,$04,$0E,$08,$04,$00,$0C,$04,$04,$0E ; 0450
.db $04,$0A,$00,$0C,$04,$04,$0E,$0A,$00,$00,$0C,$04,$04,$0E,$02,$04 ; 0460
.db $0E,$11,$11,$11,$0E,$08,$04,$0E,$11,$11,$11,$0E,$04,$0A,$0E,$11 ; 0470
.db $11,$11,$0E,$0A,$00,$0E,$11,$11,$11,$0E,$02,$04,$00,$0E,$11,$11 ; 0480
.db $0E,$08,$04,$00,$0E,$11,$11,$0E,$04,$0A,$00,$0E,$11,$11,$0E,$0A ; 0490
.db $00,$00,$0E,$11,$11,$0E,$02,$04,$11,$11,$11,$11,$0E ; 04A0
|
WangShuang_book/p285.asm | SmirnovKol/Learning_x86_assembly_language | 1 | 98299 | ;store a new 9th interrupt handler, in doxbox, press 'A' button, once
;'A' button is released, whole-screen 'A' are displayed
; new handler will be stored at 0000:0204
;old entry address of 9th interrupt handler will be stored at 0000:0200
assume cs:code
stack segment
db 128 dup (0)
stack ends
code segment
start: mov ax, stack
mov ss, ax
mov sp, 128
; store new 9th interrupt handler at 0000:0204
push cs
pop ds
mov si, offset int9
mov ax, 0
mov es, ax
mov di, 204h
mov cx, offset int9end - offset int9
cld
rep movsb
; store entry address of original 9th interrupt handler
mov ax, 0
mov es, ax
push es:[9*4]
pop es:[200h]
push es:[9*4+2]
pop es:[202h]
;modify the old entry address to the new one
cli
;set IF flag to 0, so next instructions won't be interrupted
mov word ptr es:[9*4], 200h
mov word ptr es:[9*4+2], 0
sti ;set IF flag to 1
; end of main program
mov ax, 4c00h
int 21h
int9: ; new 9th interrupt handler
; description: press 'A' button, when it is released, the
; screen will be full of 'A'
; params: none
; return: none
push ax
push bx
push cx
push es
push di
in al, 60h
pushf
pushf
pop bx
and bh, 11111100b
push bx
popf
mov bx, 0
mov es, bx
call dword ptr es:[200h]
;scan code for press 'A' button=1eh
;scan code for release 'A' button = 1eh + 80h = 9eh
cmp al, 9eh
jne int9ret
;cover the whole screen with 'A'
mov ax, 0b800h
mov es, ax
mov di, 0
mov cx, 2000
s: mov byte ptr es:[di], 'A'
add di, 2
loop s
int9ret:
pop di
pop es
pop cx
pop bx
pop ax
iret
int9end: nop
code ends
end start
|
oeis/069/A069178.asm | neoneye/loda-programs | 11 | 105494 | ; A069178: Centered 21-gonal numbers.
; 1,22,64,127,211,316,442,589,757,946,1156,1387,1639,1912,2206,2521,2857,3214,3592,3991,4411,4852,5314,5797,6301,6826,7372,7939,8527,9136,9766,10417,11089,11782,12496,13231,13987,14764,15562,16381,17221,18082,18964,19867,20791,21736,22702,23689,24697,25726,26776,27847,28939,30052,31186,32341,33517,34714,35932,37171,38431,39712,41014,42337,43681,45046,46432,47839,49267,50716,52186,53677,55189,56722,58276,59851,61447,63064,64702,66361,68041,69742,71464,73207,74971,76756,78562,80389,82237,84106
add $0,1
bin $0,2
mul $0,21
add $0,1
|
src/arp.asm | furrtek/GB303 | 90 | 16906 | <gh_stars>10-100
arpcommon:
and $F
ld (ARPOFFSET),a
ld a,(ARPIDX)
inc a
cp 3
jr nz,+++
xor a
+++:
ld (ARPIDX),a
ld a,(DOSLIDE)
or a
ret nz
ld a,(LASTNOTE)
ld hl,ARPOFFSET
add (hl)
sla a
ld hl,notelut
rst 0
ld (FLOW),a
inc hl
ld a,(hl)
ld (FHIGH),a
ret
|
.config/alfred/Alfred.alfredpreferences/workflows/user.workflow.D27B6AD4-C1F8-4105-8C0B-0E52489E70FE/app_TextEdit.applescript | kuanger/dotfiles | 1 | 1095 | <filename>.config/alfred/Alfred.alfredpreferences/workflows/user.workflow.D27B6AD4-C1F8-4105-8C0B-0E52489E70FE/app_TextEdit.applescript
on getTitle()
tell application id "com.apple.TextEdit"
using terms from application "TextEdit"
tell front document
return name
end tell
end using terms from
end tell
end getTitle
on getBody()
tell application id "com.apple.TextEdit"
using terms from application "TextEdit"
set thePath to path of front document
if thePath is "" then
return text of front document
else
return "file://localhost" & my path2url(thePath)
end if
end using terms from
end tell
end getBody
on path2url(thePath)
return do shell script "python -c \"import urllib, sys; print (urllib.quote(sys.argv[1]))\" " & quoted form of thePath
end path2url |
courses/fundamentals_of_ada/labs/solar_system/adv_280_low_level_programming/question_1/src/hal.ads | AdaCore/training_material | 15 | 6021 | <filename>courses/fundamentals_of_ada/labs/solar_system/adv_280_low_level_programming/question_1/src/hal.ads
------------------------------------------------------------------------------
-- --
-- Copyright (C) 2015-2016, AdaCore --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions are --
-- met: --
-- 1. Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- 2. 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. --
-- 3. Neither the name of the copyright holder 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. --
-- --
------------------------------------------------------------------------------
with Interfaces;
package HAL is
pragma Pure;
type Bit is mod 2**1 with
Size => 1;
type UInt2 is mod 2**2 with
Size => 2;
type UInt3 is mod 2**3 with
Size => 3;
type UInt4 is mod 2**4 with
Size => 4;
type UInt5 is mod 2**5 with
Size => 5;
type UInt6 is mod 2**6 with
Size => 6;
type UInt7 is mod 2**7 with
Size => 7;
type UInt9 is mod 2**9 with
Size => 9;
type UInt8 is new Interfaces.Unsigned_8;
type UInt10 is mod 2**10 with
Size => 10;
type UInt11 is mod 2**11 with
Size => 11;
type UInt12 is mod 2**12 with
Size => 12;
type UInt13 is mod 2**13 with
Size => 13;
type UInt14 is mod 2**14 with
Size => 14;
type UInt15 is mod 2**15 with
Size => 15;
type UInt16 is new Interfaces.Unsigned_16;
type UInt17 is mod 2**17 with
Size => 17;
type UInt18 is mod 2**18 with
Size => 18;
type UInt19 is mod 2**19 with
Size => 19;
type UInt20 is mod 2**20 with
Size => 20;
type UInt21 is mod 2**21 with
Size => 21;
type UInt22 is mod 2**22 with
Size => 22;
type UInt23 is mod 2**23 with
Size => 23;
type UInt24 is mod 2**24 with
Size => 24;
type UInt25 is mod 2**25 with
Size => 25;
type UInt26 is mod 2**26 with
Size => 26;
type UInt27 is mod 2**27 with
Size => 27;
type UInt28 is mod 2**28 with
Size => 28;
type UInt29 is mod 2**29 with
Size => 29;
type UInt30 is mod 2**30 with
Size => 30;
type UInt31 is mod 2**31 with
Size => 31;
type UInt32 is new Interfaces.Unsigned_32;
type UInt33 is mod 2**33 with
Size => 33;
type UInt34 is mod 2**34 with
Size => 34;
type UInt35 is mod 2**35 with
Size => 35;
type UInt36 is mod 2**36 with
Size => 36;
type UInt37 is mod 2**37 with
Size => 37;
type UInt38 is mod 2**38 with
Size => 38;
type UInt39 is mod 2**39 with
Size => 39;
type UInt40 is mod 2**40 with
Size => 40;
type UInt41 is mod 2**41 with
Size => 41;
type UInt42 is mod 2**42 with
Size => 42;
type UInt43 is mod 2**43 with
Size => 43;
type UInt44 is mod 2**44 with
Size => 44;
type UInt45 is mod 2**45 with
Size => 45;
type UInt46 is mod 2**46 with
Size => 46;
type UInt47 is mod 2**47 with
Size => 47;
type UInt48 is mod 2**48 with
Size => 48;
type UInt49 is mod 2**49 with
Size => 49;
type UInt50 is mod 2**50 with
Size => 50;
type UInt51 is mod 2**51 with
Size => 51;
type UInt52 is mod 2**52 with
Size => 52;
type UInt53 is mod 2**53 with
Size => 53;
type UInt54 is mod 2**54 with
Size => 54;
type UInt55 is mod 2**55 with
Size => 55;
type UInt56 is mod 2**56 with
Size => 56;
type UInt57 is mod 2**57 with
Size => 57;
type UInt58 is mod 2**58 with
Size => 58;
type UInt59 is mod 2**59 with
Size => 59;
type UInt60 is mod 2**60 with
Size => 60;
type UInt61 is mod 2**61 with
Size => 61;
type UInt62 is mod 2**62 with
Size => 62;
type UInt63 is mod 2**63 with
Size => 63;
type UInt64 is new Interfaces.Unsigned_64;
type UInt8_Array is array (Natural range <>) of UInt8;
type UInt16_Array is array (Natural range <>) of UInt16;
type UInt32_Array is array (Natural range <>) of UInt32;
end HAL;
|
src/shaders/h264/mc/SetupForHWMC.asm | tizenorg/platform.upstream.libva-intel-driver | 0 | 14439 | /*
* Initial setup for running HWMC kernels in HWMC-Only decoding mode
* Copyright © <2010>, Intel Corporation.
*
* This program is licensed under the terms and conditions of the
* Eclipse Public License (EPL), version 1.0. The full text of the EPL is at
* http://www.opensource.org/licenses/eclipse-1.0.php.
*
*/
// Kernel name: SetupForHWMC.asm
//
// Initial setup for running HWMC kernels in HWMC-Only decoding mode
//
#include "header.inc"
#include "intra_Header.inc"
#if !defined(__SETUPFORHWMC__) // Make sure the following are only included once
#define __SETUPFORHWMC__
.reg_count_total 64
.reg_count_payload 2
//
// Now, begin source code....
//
.code
#endif // !defined(__SETUPFORHWMC__)
mov (8) MSGSRC<1>:ud r0.0<8;8,1>:ud // Initialize message header payload with R0
shl (2) I_ORIX<1>:uw ORIX<2;2,1>:ub 4:w // Convert MB origin to pixel unit
// End of SetupForHWMC
|
kernel/arch/x86/kernel/_start.asm | GhostBirdOperatingSystemProject/GhostBirdOS | 10 | 2141 | <gh_stars>1-10
;Copyright 2013-2015 by Explorer Developers.
;made by Lab Explorer Developers<<EMAIL>>
;Explorer function _start
;Explorer/arch/kernel/_start.asm
;version:Alpha
;7/9/2014 8:25 AM:created
;1/3/2015 3:23 PM:cancel function kernel_start
;1/18/2015 12:18 PM:add init for arch code from fun_c.c
;Explorer在x86平台地址管理的相关信息*/
;全局描述符表(64KB)
GDT_addr equ 0x60000
GDT_size equ 65536
;全局变量及全局函数
extern task_0 ;任务0的联合体，在Explorer/arch/x86/kernel/task/task.c中定义
extern init_Architecture ;初始化架构函数，在Explorer/arch/x86/Architecture.c中实现
extern main ;内核的主函数，位于Explorer/init/main.c中实现
global _start ;内核的入口函数
global boot_info_ptr ;指向boot_info的指针*/
;TSC函数
global read_tsc
;初始化段寄存器函数
global init_seg_reg
;描述符寄存器操作函数
global write_IDTR
global write_TR
global write_GDTR
;IDT操作函数
global clean_IDT
global create_IDT
;GDT操作函数
global clean_GDT
global set_GDT
;控制寄存器读写
global read_CR0,write_CR0
global read_CR2,write_CR2
global read_CR3,write_CR3
;特殊大小内存读写函数
global write_mem24
TASK_SIZE equ 8192
;相关宏定义
;void write_IDTR(u32 IDTR.base, u16 IDTR.size)
%macro call_write_IDTR 2
push word %2
push dword %1
call write_IDTR
add esp,6
%endmacro
;void write_GDTR(u32 GDTR.base, u16 GDTR.size)
%macro call_write_GDTR 2
push word %2
push dword %1
call write_GDTR
add esp,6
%endmacro
;void write_TR(u16 selector)
%macro call_write_TR 1
push word %1
call write_TR
add esp,2
%endmacro
;u16 set_GDT(u32 segment_base, u32 limit, u32 attribute)
%macro call_set_GDT 3
push dword %3
push dword %2
push dword %1
call set_GDT
add esp,12
%endmacro
;void create_IDT(u32 number, u32 selector, u32 offset, u32 attribute)
%macro call_create_IDT 4
push dword %4
push dword %3
push dword %2
push dword %1
call create_IDT
add esp,16
%endmacro
;全局描述符表的相关宏定义
%define GDT_G 0x800000
%define GDT_P 0x8000
%define GDT_DPL_0 0x00
%define GDT_DPL_1 0x2000
%define GDT_DPL_2 0x4000
%define GDT_DPL_3 0x6000
;注意:都为可读的代码段
%define GDT_code_32_conforming 0x401E00
%define GDT_code_32_non_conforming 0x401A00
;为向上的数据段，向下的数据段有风险，不可使用
%define GDT_data_32 0x200
;系统段
%define GDT_TSS_data 0x900
;NOTICE:能自由使用的寄存器只有EAX\ECX\EDX
[section .text]
[bits 32]
;整个内核的入口函数
_start:
;初始化堆栈指针指向内核栈
mov esp,task_0 + TASK_SIZE
;将eax代表的启动信息放入启动信息指针中
mov [boot_info_ptr],eax
;初始化平台相关信息
call init_Architecture
;调用主函数开始进行各项的初始化
call main
;怠速运行
.sleep:
hlt
jmp .sleep
strr db "_start: window test",0x00
;平台相关控制代码
;初始化段寄存器函数
init_seg_reg:
mov ax,[esp+4]
mov ds,ax
mov es,ax
mov fs,ax
mov gs,ax
mov ss,ax
ret
;时间戳寄存器(Time Stamp Counter，TSC)从奔腾(Pentium)系列开始被引入，
;是x86 CPU中一个特殊的寄存器，该寄存器在CPU每经过一个时钟周期时加1，
;当计算机reset后，TSC将被清空。
;TSC是个64位的寄存器，使用rdtsc指令读取它。指令执行后，EAX：EDX存放TSC的值。
;3GHz的CPU运行195年，TSC寄存器才会溢出。
;TSC读取函数
read_tsc:
rdtsc
ret
;描述符寄存器操作函数
write_IDTR:
;void write_IDT(u32 base, u16 size)
mov eax,[esp+4]
mov [IDTR.base],eax
mov ax,[esp+8]
mov [IDTR.size],ax
lidt [cs:IDTR] ;加载IDTR
ret
write_TR:
;void write_TR(u16 select)
mov ax,[esp+4]
ltr ax
ret
write_GDTR:
;void write_GDTR(u32 base, u16 size)
mov eax,[esp+4]
mov [GDTR.base],eax
mov ax,[esp+8]
mov [GDTR.size],ax
lgdt [cs:GDTR] ;加载GDTR
ret
;IDT操作函数
clean_IDT:
;void clean_IDT(void)
mov edx,[IDTR.base]
mov ecx,IDTR.size
shr ecx,2
.loop:
mov dword[edx],0x0
add edx,4
loop .loop
ret
create_IDT:
;void create_IDT(u32 number, u32 selector, u32 offset, u32 attribute)
xor eax,eax
mov al,[esp+4] ;number参数
shl eax,3 ;相当于乘8
add eax,[IDTR.base];加上addr的起始地址
mov dx,[esp+8] ;selector参数
mov [eax+2],dx
mov edx,[esp+12] ;offset参数
mov [eax],dx ;dx=offset低16位
shr edx,16
mov [eax+6],dx ;dx=offset高16位
mov word[eax+4],0;清空属性区域
mov edx,[esp+16];attribute参数
add [eax+4],edx ;加上属性
ret
;GDT操作函数
clean_GDT:
;void clean_GDT(void)
mov edx,[GDTR.base]
mov ecx,GDTR.size
shr ecx,2
.loop:
mov dword[edx],0x0
add edx,4
loop .loop
ret
set_GDT:
;u16 set_GDT(u32 segment_base, u32 limit, u32 attribute)
push ebp
mov ebp,esp
push esi
;表基地址
mov esi,[GDTR.base]
.loop:
;跳过空描述符以及循环查找功能
add esi,8
;判断该GDT表项是否是8字节的0
cmp dword[esi],0x00
jnz .loop
cmp dword[esi+4],0x00
jnz .loop
;将段基址放置到GDT中
mov eax,[ebp+8]
mov [esi+2],ax
shr eax,16
mov [esi+4],al
mov [esi+7],ah
;将界限放置到GDT
mov eax,[ebp+12]
mov [esi],ax
;震荡eax,保证高12位为0
shl eax,12
shr eax,12+16
mov [esi+6],al
;将属性加入表项中
mov eax,[ebp+16]
add [esi+4],eax
;计算出select value
mov eax,esi
sub eax,[GDTR.base]
pop esi
pop ebp
ret
;控制寄存器的读写
read_CR0:
mov eax,cr0
ret
read_CR2:
mov eax,cr2
ret
read_CR3:
mov eax,cr3
ret
write_CR0:
mov eax,[esp+4]
mov cr0,eax
ret
write_CR2:
mov eax,[esp+4]
mov cr2,eax
ret
write_CR3:
mov eax,[esp+4]
mov cr3,eax
ret
write_mem24:
mov edx,[esp+8]
mov ecx,[esp+4]
mov [ecx],dx
shr dx,16
mov [ecx+2],dl
ret
;数据区
[section .data]
;启动信息结构体指针*/
boot_info_ptr dd 0
;GDTR
GDTR:
.size dw 0 ;GDT的长度
.base dd 0 ;GDT的物理地址
;IDTR
IDTR:
.size dw 0 ;IDT的长度
.base dd 0 ;IDT的物理地址 |
Transynther/x86/_processed/AVXALIGN/_zr_/i3-7100_9_0x84_notsx.log_21829_600.asm | ljhsiun2/medusa | 9 | 25364 | <reponame>ljhsiun2/medusa
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r15
push %r9
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0xff25, %rsi
nop
nop
xor $46352, %r15
and $0xffffffffffffffc0, %rsi
movaps (%rsi), %xmm2
vpextrq $0, %xmm2, %rax
nop
nop
nop
dec %r10
lea addresses_A_ht+0xc18f, %rbp
nop
nop
cmp %r11, %r11
movw $0x6162, (%rbp)
nop
xor $37162, %r11
lea addresses_WC_ht+0x1b28f, %rsi
cmp $25216, %r11
movw $0x6162, (%rsi)
nop
nop
nop
cmp $24988, %rax
lea addresses_normal_ht+0x5e2f, %rsi
lea addresses_UC_ht+0x153af, %rdi
nop
nop
nop
nop
cmp $27194, %rbp
mov $116, %rcx
rep movsw
nop
nop
sub $31395, %r10
lea addresses_UC_ht+0x270f, %r15
nop
nop
nop
nop
inc %rbp
movups (%r15), %xmm0
vpextrq $1, %xmm0, %rsi
nop
xor $36037, %rcx
lea addresses_A_ht+0xb28f, %rsi
lea addresses_normal_ht+0x3706, %rdi
nop
nop
nop
nop
nop
cmp $38220, %r11
mov $52, %rcx
rep movsw
nop
nop
nop
nop
xor $13982, %r11
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r9
pop %r15
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r15
push %r8
push %rbp
push %rbx
push %rcx
push %rdi
// Store
lea addresses_WT+0x464f, %r15
clflush (%r15)
nop
xor %r10, %r10
mov $0x5152535455565758, %r8
movq %r8, (%r15)
cmp %r15, %r15
// Load
lea addresses_WT+0x1b28f, %r15
nop
nop
nop
cmp $40957, %rbp
mov (%r15), %ecx
nop
nop
and $58930, %rbp
// Faulty Load
lea addresses_WT+0x1b28f, %r10
sub %rdi, %rdi
vmovaps (%r10), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $0, %xmm0, %rbx
lea oracles, %rdi
and $0xff, %rbx
shlq $12, %rbx
mov (%rdi,%rbx,1), %rbx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r8
pop %r15
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WT', 'same': False, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WT', 'same': False, 'size': 8, 'congruent': 6, 'NT': True, 'AVXalign': True}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WT', 'same': True, 'size': 4, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_WT', 'same': True, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 16, 'congruent': 1, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 2, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_WC_ht', 'same': False, 'size': 2, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': True}, 'OP': 'REPM'}
{'src': {'type': 'addresses_UC_ht', 'same': False, 'size': 16, 'congruent': 6, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A_ht', 'congruent': 9, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM'}
{'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
*/
|
oeis/081/A081422.asm | neoneye/loda-programs | 11 | 89745 | ; A081422: Triangle read by rows in which row n consists of the first n+1 n-gonal numbers.
; Submitted by <NAME>
; 1,1,1,1,2,3,1,3,6,10,1,4,9,16,25,1,5,12,22,35,51,1,6,15,28,45,66,91,1,7,18,34,55,81,112,148,1,8,21,40,65,96,133,176,225,1,9,24,46,75,111,154,204,261,325,1,10,27,52,85,126,175,232,297,370,451,1,11,30,58,95,141,196,260,333,415,506,606,1,12,33,64,105,156,217,288,369,460,561,672,793,1,13,36,70,115,171,238,316,405
lpb $0
add $1,1
sub $0,$1
lpe
sub $1,3
mul $1,$0
add $0,1
add $1,$0
mul $1,$0
add $0,$1
div $0,2
|
progs/chap05p06-reverse.asm | HKhademian/AssemblyDandamudi | 1 | 167581 | %include "lib.asm"
extern ExitProcess
global _start
section .bss
MAX EQU 1000
NULL EQU 0
text1 resb MAX
buffer resb 25
section .code
reverse:
%define str1 DWORD [EBP+8]
enter 0,0
push ESI
push EDI
push EAX
mov ESI, str1
mov EDI, str1
dec EDI
reverse_edi_end:
inc EDI
cmp BYTE [EDI], NULL
jne reverse_edi_end
dec ESI
reverse_loop:
inc ESI
dec EDI
cmp ESI, EDI
jae reverse_loop_done
mov AL, [ESI]
mov AH, [EDI]
mov [ESI], AH
mov [EDI], AL
jmp reverse_loop
reverse_loop_done:
pop EAX
pop EDI
pop ESI
leave
ret 4
_start:
fgets text1, MAX
push text1
call reverse
puts text1
_end:
push DWORD 0
call ExitProcess
|
src/gnat/casing.adb | Letractively/ada-gen | 0 | 24177 | ------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- C A S I N G --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2009 Free Software Foundation, Inc. --
-- --
-- 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. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- 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 was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
with Csets; use Csets;
with Namet; use Namet;
with Opt; use Opt;
with Widechar; use Widechar;
package body Casing is
----------------------
-- Determine_Casing --
----------------------
function Determine_Casing (Ident : Text_Buffer) return Casing_Type is
All_Lower : Boolean := True;
-- Set False if upper case letter found
All_Upper : Boolean := True;
-- Set False if lower case letter found
Mixed : Boolean := True;
-- Set False if exception to mixed case rule found (lower case letter
-- at start or after underline, or upper case letter elsewhere).
Decisive : Boolean := False;
-- Set True if at least one instance of letter not after underline
After_Und : Boolean := True;
-- True at start of string, and after an underline character
begin
for S in Ident'Range loop
if Ident (S) = '_' or else Ident (S) = '.' then
After_Und := True;
elsif Is_Lower_Case_Letter (Ident (S)) then
All_Upper := False;
if not After_Und then
Decisive := True;
else
After_Und := False;
Mixed := False;
end if;
elsif Is_Upper_Case_Letter (Ident (S)) then
All_Lower := False;
if not After_Und then
Decisive := True;
Mixed := False;
else
After_Und := False;
end if;
end if;
end loop;
-- Now we can figure out the result from the flags we set in that loop
if All_Lower then
return All_Lower_Case;
elsif not Decisive then
return Unknown;
elsif All_Upper then
return All_Upper_Case;
elsif Mixed then
return Mixed_Case;
else
return Unknown;
end if;
end Determine_Casing;
------------------------
-- Set_All_Upper_Case --
------------------------
procedure Set_All_Upper_Case is
begin
Set_Casing (All_Upper_Case);
end Set_All_Upper_Case;
----------------
-- Set_Casing --
----------------
procedure Set_Casing (C : Casing_Type; D : Casing_Type := Mixed_Case) is
Ptr : Natural;
Actual_Casing : Casing_Type;
-- Set from C or D as appropriate
After_Und : Boolean := True;
-- True at start of string, and after an underline character or after
-- any other special character that is not a normal identifier char).
begin
if C /= Unknown then
Actual_Casing := C;
else
Actual_Casing := D;
end if;
Ptr := 1;
while Ptr <= Name_Len loop
-- Wide character. Note that we do nothing with casing in this case.
-- In Ada 2005 mode, required folding of lower case letters happened
-- as the identifier was scanned, and we do not attempt any further
-- messing with case (note that in any case we do not know how to
-- fold upper case to lower case in wide character mode). We also
-- do not bother with recognizing punctuation as equivalent to an
-- underscore. There is nothing functional at this stage in doing
-- the requested casing operation, beyond folding to upper case
-- when it is mandatory, which does not involve underscores.
if Name_Buffer (Ptr) = ASCII.ESC
or else Name_Buffer (Ptr) = '['
or else (Upper_Half_Encoding
and then Name_Buffer (Ptr) in Upper_Half_Character)
then
Skip_Wide (Name_Buffer, Ptr);
After_Und := False;
-- Underscore, or non-identifer character (error case)
elsif Name_Buffer (Ptr) = '_'
or else not Identifier_Char (Name_Buffer (Ptr))
then
After_Und := True;
Ptr := Ptr + 1;
-- Lower case letter
elsif Is_Lower_Case_Letter (Name_Buffer (Ptr)) then
if Actual_Casing = All_Upper_Case
or else (After_Und and then Actual_Casing = Mixed_Case)
then
Name_Buffer (Ptr) := Fold_Upper (Name_Buffer (Ptr));
end if;
After_Und := False;
Ptr := Ptr + 1;
-- Upper case letter
elsif Is_Upper_Case_Letter (Name_Buffer (Ptr)) then
if Actual_Casing = All_Lower_Case
or else (not After_Und and then Actual_Casing = Mixed_Case)
then
Name_Buffer (Ptr) := Fold_Lower (Name_Buffer (Ptr));
end if;
After_Und := False;
Ptr := Ptr + 1;
-- Other identifier character (must be digit)
else
After_Und := False;
Ptr := Ptr + 1;
end if;
end loop;
end Set_Casing;
end Casing;
|
src/sets/nat/algebra.agda | pcapriotti/agda-base | 20 | 13686 | <gh_stars>10-100
{-# OPTIONS --without-K #-}
module sets.nat.algebra where
open import equality.core
open import algebra.monoid.core
open import sets.nat.core
open import sets.nat.properties
+-monoid : Monoid _
+-monoid = record
{ carrier = ℕ
; is-mon = record
{ id = λ _ → 0
; _∘_ = _+_
; left-unit = +-left-unit
; right-unit = +-right-unit
; associativity = λ x y z → +-associativity z y x } }
*-monoid : Monoid _
*-monoid = record
{ carrier = ℕ
; is-mon = record
{ id = λ _ → 1
; _∘_ = _*_
; left-unit = *-left-unit
; right-unit = *-right-unit
; associativity = λ x y z → *-associativity z y x } }
|
code/gfx/software/sw_render.asm | NEMESIS13cz/SysBench | 3 | 13967 | [BITS 64]
global swrender_framebuffercpy
; void swrender_framebuffercpy(void* back, void* front, void* destination, uint64_t size);
swrender_framebuffercpy:
.repeat:
mov rax, [rdi]
mov r8, [rsi]
cmp rax, r8
je .jump_over
mov [rdx], rax
mov [rsi], rax
.jump_over:
add rdi, 8
add rsi, 8
add rdx, 8
dec rcx
jnz .repeat
ret
|
Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0x84_notsx.log_21829_1563.asm | ljhsiun2/medusa | 9 | 95407 | <filename>Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0x84_notsx.log_21829_1563.asm
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r12
push %r13
push %r14
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x1d6fc, %r14
clflush (%r14)
nop
nop
nop
and $31871, %r12
mov (%r14), %cx
nop
nop
nop
nop
sub $7188, %r13
lea addresses_WT_ht+0x2434, %rsi
lea addresses_WT_ht+0x40fc, %rdi
nop
nop
mfence
mov $37, %rcx
rep movsw
nop
nop
nop
and %rcx, %rcx
lea addresses_WT_ht+0x137fc, %r13
nop
nop
nop
nop
xor $38768, %r10
mov (%r13), %r14w
nop
nop
nop
nop
nop
and $24789, %rdi
lea addresses_UC_ht+0x1027c, %rcx
nop
add $27956, %rsi
mov $0x6162636465666768, %r14
movq %r14, %xmm7
vmovups %ymm7, (%rcx)
sub $30861, %r10
lea addresses_WC_ht+0x10cfc, %rdi
nop
nop
nop
cmp $3543, %r13
mov (%rdi), %r12
cmp $50893, %r10
lea addresses_normal_ht+0xbdfc, %rdi
nop
nop
nop
nop
xor $51392, %r10
movb (%rdi), %r13b
nop
nop
and $16779, %r10
pop %rsi
pop %rdi
pop %rcx
pop %r14
pop %r13
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r14
push %rcx
push %rdi
push %rdx
push %rsi
// Load
lea addresses_A+0x3afc, %rdx
nop
nop
nop
add $10894, %rsi
mov (%rdx), %r14
nop
nop
nop
nop
nop
add $50363, %rsi
// Store
lea addresses_WC+0x1a0fc, %rcx
nop
nop
nop
cmp %r14, %r14
movw $0x5152, (%rcx)
and %rdx, %rdx
// REPMOV
lea addresses_A+0x8cfc, %rsi
lea addresses_normal+0x32ea, %rdi
dec %r11
mov $69, %rcx
rep movsw
nop
nop
nop
nop
dec %r14
// Store
mov $0x59c, %r13
nop
nop
nop
nop
dec %rsi
mov $0x5152535455565758, %rdx
movq %rdx, %xmm6
vmovups %ymm6, (%r13)
cmp $37795, %rsi
// Store
lea addresses_A+0x1a0fc, %rdx
clflush (%rdx)
nop
nop
nop
nop
nop
dec %rdi
mov $0x5152535455565758, %rcx
movq %rcx, %xmm1
vmovups %ymm1, (%rdx)
nop
nop
nop
dec %rcx
// Store
lea addresses_UC+0x1a09c, %r11
nop
add $45913, %rcx
movw $0x5152, (%r11)
// Exception!!!
nop
nop
nop
mov (0), %rdx
nop
sub $38187, %rdi
// Faulty Load
lea addresses_PSE+0x78fc, %rdi
nop
nop
nop
nop
cmp %r14, %r14
movb (%rdi), %r13b
lea oracles, %rsi
and $0xff, %r13
shlq $12, %r13
mov (%rsi,%r13,1), %r13
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r14
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_PSE', 'same': False, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_A', 'same': False, 'size': 8, 'congruent': 9, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_WC', 'same': False, 'size': 2, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_A', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_normal', 'congruent': 1, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_P', 'same': False, 'size': 32, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_A', 'same': True, 'size': 32, 'congruent': 11, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_UC', 'same': False, 'size': 2, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'type': 'addresses_PSE', 'same': True, 'size': 1, 'congruent': 0, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_A_ht', 'same': False, 'size': 2, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 2, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 32, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 8, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 1, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'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/numerics-abs_max_ra.adb | sciencylab/lagrangian-solver | 0 | 16184 | separate (Numerics)
function Abs_Max_RA (Item : in Real_Vector) return Real is
Result : Real := 0.0;
begin
for N of Item loop
Result := Real'Max (Result, abs (N));
end loop;
return Result;
end Abs_Max_RA;
|
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/c3/c37304a.ada | best08618/asylo | 7 | 17317 | -- C37304A.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 ALL FORMS OF CHOICE ARE PERMITTED IN A VARIANT_PART,
-- AND, IN PARTICULAR, THAT FORMS LIKE ST RANGE L..R, AND ST ARE
-- PERMITTED.
-- ASL 7/31/81
-- RM 8/26/82
-- SPS 1/21/83
WITH REPORT;
PROCEDURE C37304A IS
USE REPORT;
BEGIN
TEST("C37304A","ALL FORMS OF CHOICE ALLOWED IN A VARIANT_PART");
DECLARE
TYPE T IS RANGE 1 .. 10;
C5 : CONSTANT T := 5;
SUBTYPE S1 IS T RANGE 1 .. 5;
SUBTYPE S2 IS T RANGE C5 + 1 .. 7;
SUBTYPE SN IS T RANGE C5 + 4 .. C5 - 4 + 7; -- NULL RANGE.
SUBTYPE S10 IS T RANGE C5 + 5 .. T'LAST;
TYPE VREC( DISC : T := 8 ) IS
RECORD
CASE DISC IS
WHEN SN -- 9..8
| S1 RANGE 1 .. 0 -- 1..0
| S2 RANGE C5 + 2 .. C5 + 1 -- 7..6
| 3 .. 2 -- 3..2
=> NULL;
WHEN S1 RANGE 4 .. C5 -- 4..5
| S1 RANGE C5 - 4 .. C5 / 2 -- 1..2
| 3 .. 1 + C5 MOD 3 -- 3..3
| SN -- 9..8
| S1 RANGE 5 .. C5 - 1 -- 5..4
| 6 .. 7 -- 6..7
| S10 -- 10..10
| 9 -- 9
| S10 RANGE 10 .. 9 -- 10..9
=> NULL;
WHEN C5 + C5 - 2 .. 8 -- 8
=> NULL;
END CASE;
END RECORD;
V : VREC;
BEGIN
IF EQUAL(3,3) THEN
V := (DISC => 5);
END IF;
IF V.DISC /= 5 THEN
FAILED ("ASSIGNMENT FAILED");
END IF;
END;
RESULT;
END C37304A;
|
src/Categories/NaturalTransformation/NaturalIsomorphism/Monoidal/Symmetric.agda | o1lo01ol1o/agda-categories | 0 | 2914 | <reponame>o1lo01ol1o/agda-categories<filename>src/Categories/NaturalTransformation/NaturalIsomorphism/Monoidal/Symmetric.agda
{-# OPTIONS --without-K --safe #-}
-- Monoidal natural isomorphisms between lax and strong symmetric
-- monoidal functors.
--
-- NOTE. Symmetric monoidal natural isomorphisms are really just
-- monoidal natural isomorphisms that happen to go between symmetric
-- monoidal functors. No additional conditions are necessary.
-- Nevertheless, the definitions in this module are useful when one is
-- working in a symmetric monoidal setting. They also help Agda's
-- type checker by bundling the (symmetric monoidal) categories and
-- functors involved.
module Categories.NaturalTransformation.NaturalIsomorphism.Monoidal.Symmetric
where
open import Level
open import Relation.Binary using (IsEquivalence)
open import Categories.Category.Monoidal using (SymmetricMonoidalCategory)
import Categories.Functor.Monoidal.Symmetric as BMF
open import Categories.Functor.Monoidal.Properties using () renaming
( idF-SymmetricMonoidal to idFˡ ; idF-StrongSymmetricMonoidal to idFˢ
; ∘-SymmetricMonoidal to _∘Fˡ_ ; ∘-StrongSymmetricMonoidal to _∘Fˢ_
)
open import Categories.NaturalTransformation.NaturalIsomorphism as NI
using (NaturalIsomorphism)
import Categories.NaturalTransformation.NaturalIsomorphism.Monoidal as MNI
module Lax where
open BMF.Lax using (SymmetricMonoidalFunctor)
open MNI.Lax using (IsMonoidalNaturalIsomorphism)
open SymmetricMonoidalFunctor using ()
renaming (F to UF; monoidalFunctor to MF)
private module U = MNI.Lax
module _ {o ℓ e o′ ℓ′ e′}
{C : SymmetricMonoidalCategory o ℓ e}
{D : SymmetricMonoidalCategory o′ ℓ′ e′} where
-- Monoidal natural isomorphisms between lax symmetric monoidal functors.
record SymmetricMonoidalNaturalIsomorphism
(F G : SymmetricMonoidalFunctor C D) : Set (o ⊔ ℓ ⊔ ℓ′ ⊔ e′) where
field
U : NaturalIsomorphism (UF F) (UF G)
F⇒G-isMonoidal : IsMonoidalNaturalIsomorphism (MF F) (MF G) U
⌊_⌋ : U.MonoidalNaturalIsomorphism (MF F) (MF G)
⌊_⌋ = record { U = U ; F⇒G-isMonoidal = F⇒G-isMonoidal }
open U.MonoidalNaturalIsomorphism ⌊_⌋ public hiding (U; F⇒G-isMonoidal)
infix 4 _≃_
_≃_ = SymmetricMonoidalNaturalIsomorphism
-- "Strengthening"
⌈_⌉ : {F G : SymmetricMonoidalFunctor C D} →
U.MonoidalNaturalIsomorphism (MF F) (MF G) → F ≃ G
⌈ α ⌉ = record { U = U ; F⇒G-isMonoidal = F⇒G-isMonoidal }
where open U.MonoidalNaturalIsomorphism α
open SymmetricMonoidalNaturalIsomorphism
-- Identity and compositions
infixr 9 _ⓘᵥ_
id : {F : SymmetricMonoidalFunctor C D} → F ≃ F
id = ⌈ U.id ⌉
_ⓘᵥ_ : {F G H : SymmetricMonoidalFunctor C D} → G ≃ H → F ≃ G → F ≃ H
α ⓘᵥ β = ⌈ ⌊ α ⌋ U.ⓘᵥ ⌊ β ⌋ ⌉
isEquivalence : IsEquivalence _≃_
isEquivalence = record
{ refl = id
; sym = λ α → record
{ U = NI.sym (U α)
; F⇒G-isMonoidal = F⇐G-isMonoidal α
}
; trans = λ α β → β ⓘᵥ α
}
where
open SymmetricMonoidalNaturalIsomorphism
module _ {o ℓ e o′ ℓ′ e′ o″ ℓ″ e″}
{C : SymmetricMonoidalCategory o ℓ e}
{D : SymmetricMonoidalCategory o′ ℓ′ e′}
{E : SymmetricMonoidalCategory o″ ℓ″ e″} where
infixr 9 _ⓘₕ_ _ⓘˡ_ _ⓘʳ_
_ⓘₕ_ : {F G : SymmetricMonoidalFunctor C D}
{H I : SymmetricMonoidalFunctor D E} →
H ≃ I → F ≃ G → (H ∘Fˡ F) ≃ (I ∘Fˡ G)
-- NOTE: this definition is clearly equivalent to
--
-- α ⓘₕ β = ⌈ ⌊ α ⌋ U.ⓘₕ ⌊ β ⌋ ⌉
--
-- but the latter takes an unreasonably long time to typecheck,
-- while the unfolded version typechecks almost immediately.
α ⓘₕ β = record
{ U = C.U
; F⇒G-isMonoidal = record
{ ε-compat = C.ε-compat
; ⊗-homo-compat = C.⊗-homo-compat }
}
where module C = U.MonoidalNaturalIsomorphism (⌊ α ⌋ U.ⓘₕ ⌊ β ⌋)
_ⓘˡ_ : {F G : SymmetricMonoidalFunctor C D}
(H : SymmetricMonoidalFunctor D E) → F ≃ G → (H ∘Fˡ F) ≃ (H ∘Fˡ G)
H ⓘˡ α = id {F = H} ⓘₕ α
_ⓘʳ_ : {G H : SymmetricMonoidalFunctor D E} →
G ≃ H → (F : SymmetricMonoidalFunctor C D) → (G ∘Fˡ F) ≃ (H ∘Fˡ F)
α ⓘʳ F = α ⓘₕ id {F = F}
-- Left and right unitors.
module _ {o ℓ e o′ ℓ′ e′}
{C : SymmetricMonoidalCategory o ℓ e}
{D : SymmetricMonoidalCategory o′ ℓ′ e′}
{F : SymmetricMonoidalFunctor C D} where
-- NOTE: Again, manual expansion seems necessary to type check in
-- reasonable time.
unitorˡ : idFˡ D ∘Fˡ F ≃ F
unitorˡ = record
{ U = LU.U
; F⇒G-isMonoidal = record
{ ε-compat = LU.ε-compat
; ⊗-homo-compat = LU.⊗-homo-compat
}
}
where module LU = U.MonoidalNaturalIsomorphism (U.unitorˡ {F = MF F})
unitorʳ : F ∘Fˡ idFˡ C ≃ F
unitorʳ = record
{ U = RU.U
; F⇒G-isMonoidal = record
{ ε-compat = RU.ε-compat
; ⊗-homo-compat = RU.⊗-homo-compat
}
}
where module RU = U.MonoidalNaturalIsomorphism (U.unitorʳ {F = MF F})
-- Associator.
module _ {o ℓ e o′ ℓ′ e′ o″ ℓ″ e″ o‴ ℓ‴ e‴}
{B : SymmetricMonoidalCategory o ℓ e}
{C : SymmetricMonoidalCategory o′ ℓ′ e′}
{D : SymmetricMonoidalCategory o″ ℓ″ e″}
{E : SymmetricMonoidalCategory o‴ ℓ‴ e‴}
{F : SymmetricMonoidalFunctor B C}
{G : SymmetricMonoidalFunctor C D}
{H : SymmetricMonoidalFunctor D E} where
-- NOTE: Again, manual expansion seems necessary to type check in
-- reasonable time.
associator : (H ∘Fˡ G) ∘Fˡ F ≃ H ∘Fˡ (G ∘Fˡ F)
associator = record
{ U = AU.U
; F⇒G-isMonoidal = record
{ ε-compat = AU.ε-compat
; ⊗-homo-compat = AU.⊗-homo-compat
}
}
where
module AU =
U.MonoidalNaturalIsomorphism (U.associator {F = MF F} {MF G} {MF H})
module Strong where
open BMF.Strong using (SymmetricMonoidalFunctor)
open MNI.Strong using (IsMonoidalNaturalIsomorphism)
open SymmetricMonoidalFunctor using () renaming
( F to UF
; monoidalFunctor to MF
; laxSymmetricMonoidalFunctor to laxBMF
)
private module U = MNI.Strong
module _ {o ℓ e o′ ℓ′ e′}
{C : SymmetricMonoidalCategory o ℓ e}
{D : SymmetricMonoidalCategory o′ ℓ′ e′} where
-- Monoidal natural isomorphisms between strong symmetric monoidal functors.
record SymmetricMonoidalNaturalIsomorphism
(F G : SymmetricMonoidalFunctor C D) : Set (o ⊔ ℓ ⊔ ℓ′ ⊔ e′) where
field
U : NaturalIsomorphism (UF F) (UF G)
F⇒G-isMonoidal : IsMonoidalNaturalIsomorphism (MF F) (MF G) U
⌊_⌋ : U.MonoidalNaturalIsomorphism (MF F) (MF G)
⌊_⌋ = record { U = U ; F⇒G-isMonoidal = F⇒G-isMonoidal }
laxBNI : Lax.SymmetricMonoidalNaturalIsomorphism (laxBMF F) (laxBMF G)
laxBNI = record { U = U ; F⇒G-isMonoidal = F⇒G-isMonoidal }
open Lax.SymmetricMonoidalNaturalIsomorphism laxBNI public
hiding (U; F⇒G-isMonoidal; ⌊_⌋)
infix 4 _≃_
_≃_ = SymmetricMonoidalNaturalIsomorphism
-- "Strengthening"
⌈_⌉ : {F G : SymmetricMonoidalFunctor C D} →
U.MonoidalNaturalIsomorphism (MF F) (MF G) → F ≃ G
⌈ α ⌉ = record { U = U ; F⇒G-isMonoidal = F⇒G-isMonoidal }
where open U.MonoidalNaturalIsomorphism α
open SymmetricMonoidalNaturalIsomorphism
-- Identity and compositions
infixr 9 _ⓘᵥ_
id : {F : SymmetricMonoidalFunctor C D} → F ≃ F
id = ⌈ U.id ⌉
_ⓘᵥ_ : {F G H : SymmetricMonoidalFunctor C D} → G ≃ H → F ≃ G → F ≃ H
α ⓘᵥ β = ⌈ ⌊ α ⌋ U.ⓘᵥ ⌊ β ⌋ ⌉
isEquivalence : IsEquivalence _≃_
isEquivalence = record
{ refl = id
; sym = λ α → record
{ U = NI.sym (U α)
; F⇒G-isMonoidal = F⇐G-isMonoidal α
}
; trans = λ α β → β ⓘᵥ α
}
where
open SymmetricMonoidalNaturalIsomorphism
module _ {o ℓ e o′ ℓ′ e′ o″ ℓ″ e″}
{C : SymmetricMonoidalCategory o ℓ e}
{D : SymmetricMonoidalCategory o′ ℓ′ e′}
{E : SymmetricMonoidalCategory o″ ℓ″ e″} where
infixr 9 _ⓘₕ_ _ⓘˡ_ _ⓘʳ_
_ⓘₕ_ : {F G : SymmetricMonoidalFunctor C D}
{H I : SymmetricMonoidalFunctor D E} →
H ≃ I → F ≃ G → (H ∘Fˢ F) ≃ (I ∘Fˢ G)
-- NOTE: this definition is clearly equivalent to
--
-- α ⓘₕ β = ⌈ ⌊ α ⌋ U.ⓘₕ ⌊ β ⌋ ⌉
--
-- but the latter takes an unreasonably long time to typecheck,
-- while the unfolded version typechecks almost immediately.
α ⓘₕ β = record
{ U = C.U
; F⇒G-isMonoidal = record
{ ε-compat = C.ε-compat
; ⊗-homo-compat = C.⊗-homo-compat }
}
where module C = U.MonoidalNaturalIsomorphism (⌊ α ⌋ U.ⓘₕ ⌊ β ⌋)
_ⓘˡ_ : {F G : SymmetricMonoidalFunctor C D}
(H : SymmetricMonoidalFunctor D E) → F ≃ G → (H ∘Fˢ F) ≃ (H ∘Fˢ G)
H ⓘˡ α = id {F = H} ⓘₕ α
_ⓘʳ_ : {G H : SymmetricMonoidalFunctor D E} →
G ≃ H → (F : SymmetricMonoidalFunctor C D) → (G ∘Fˢ F) ≃ (H ∘Fˢ F)
α ⓘʳ F = α ⓘₕ id {F = F}
-- Left and right unitors.
module _ {o ℓ e o′ ℓ′ e′}
{C : SymmetricMonoidalCategory o ℓ e}
{D : SymmetricMonoidalCategory o′ ℓ′ e′}
{F : SymmetricMonoidalFunctor C D} where
-- NOTE: Again, manual expansion seems necessary to type check in
-- reasonable time.
unitorˡ : idFˢ D ∘Fˢ F ≃ F
unitorˡ = record
{ U = LU.U
; F⇒G-isMonoidal = record
{ ε-compat = LU.ε-compat
; ⊗-homo-compat = LU.⊗-homo-compat
}
}
where module LU = U.MonoidalNaturalIsomorphism (U.unitorˡ {F = MF F})
unitorʳ : F ∘Fˢ idFˢ C ≃ F
unitorʳ = record
{ U = RU.U
; F⇒G-isMonoidal = record
{ ε-compat = RU.ε-compat
; ⊗-homo-compat = RU.⊗-homo-compat
}
}
where module RU = U.MonoidalNaturalIsomorphism (U.unitorʳ {F = MF F})
-- Associator.
module _ {o ℓ e o′ ℓ′ e′ o″ ℓ″ e″ o‴ ℓ‴ e‴}
{B : SymmetricMonoidalCategory o ℓ e}
{C : SymmetricMonoidalCategory o′ ℓ′ e′}
{D : SymmetricMonoidalCategory o″ ℓ″ e″}
{E : SymmetricMonoidalCategory o‴ ℓ‴ e‴}
{F : SymmetricMonoidalFunctor B C}
{G : SymmetricMonoidalFunctor C D}
{H : SymmetricMonoidalFunctor D E} where
-- NOTE: Again, manual expansion seems necessary to type check in
-- reasonable time.
associator : (H ∘Fˢ G) ∘Fˢ F ≃ H ∘Fˢ (G ∘Fˢ F)
associator = record
{ U = AU.U
; F⇒G-isMonoidal = record
{ ε-compat = AU.ε-compat
; ⊗-homo-compat = AU.⊗-homo-compat
}
}
where
module AU =
U.MonoidalNaturalIsomorphism (U.associator {F = MF F} {MF G} {MF H})
|
flycheck/test/resources/language/ada/hello.adb | beyondmetis/.emacs.d | 0 | 5205 | <filename>flycheck/test/resources/language/ada/hello.adb
with Ada.Text_IO;
with Ada.Command_Line;
procedure Hello is
package IO renames Ada.Text_IO;
Name : String := Ada.Command_Line.Argument (1);
begin
pragma Foo;
IO.Put_Line("Hello, world!");
IO.New_Line;
end Hello;
|
backend/tests/functional/run_program/test_run_singlefile_error_ada/test.adb | spanners/learn-adacore-com | 71 | 2868 | <reponame>spanners/learn-adacore-com
with Ada.Text_IO; use Ada.Text_IO;
procedure Test is
begin
Put_Line ("ABC123")
end Test; |
Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xa0.log_21829_1308.asm | ljhsiun2/medusa | 9 | 92325 | .global s_prepare_buffers
s_prepare_buffers:
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r8
push %rcx
// Faulty Load
lea addresses_A+0x546f, %r11
nop
nop
nop
sub %r10, %r10
mov (%r11), %cx
lea oracles, %r10
and $0xff, %rcx
shlq $12, %rcx
mov (%r10,%rcx,1), %rcx
pop %rcx
pop %r8
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_A', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'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
*/
|
AAOSL/Concrete.agda | LaudateCorpus1/aaosl-agda | 9 | 2107 | {- Formal verification of authenticated append-only skiplists in Agda, version 1.0.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import Data.Empty
open import Data.Sum
open import Data.Fin using (Fin; toℕ ; fromℕ ; fromℕ≤)
open import Data.Fin.Properties using (toℕ<n; toℕ-injective)
open import Data.Nat renaming (_≟_ to _≟ℕ_; _≤?_ to _≤?ℕ_)
open import Data.Nat.Properties
open import Data.List renaming (map to List-map)
open import Data.List.Relation.Unary.Any
open import Function
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary
-- This module pulls in the definitions from AAOSL.Hops and uses
-- them to construct a DepRel based on the dependency relation
-- defined there, showing that this concrete AAOSL enjoys the
-- properties we have proved for abstract ones
module AAOSL.Concrete where
open import Data.Nat.Even
open import Data.Nat.Encode
open import AAOSL.Lemmas
open import AAOSL.Hops
open import AAOSL.Abstract.Hash
open import AAOSL.Abstract.DepRel
---------------------------------------------------
-- Translating the proofs about Hops into a DepRel,
-- as required by AAOSL.Abstract.Advancement
getHop : ∀{j}(h : Fin (lvlOf j)) → H (toℕ h) j (j ∸ 2 ^ toℕ h)
getHop {j} h = h-correct j (toℕ h) (toℕ<n {lvlOf j} h)
hop-prog : {m : ℕ} (h : Fin (lvlOf m)) → m ∸ (2 ^ toℕ h) ≢ m
hop-prog {zero} ()
hop-prog {suc m} h = ∸-≢ (2 ^ toℕ h) (1≤2^n (toℕ h)) (lvlOf-correct (toℕ<n h))
hop-≤ : {m : ℕ} (h : Fin (lvlOf m)) → m ∸ (2 ^ toℕ h) ≤ m
hop-≤ {zero} ()
hop-≤ {suc m} h = m∸n≤m (suc m) (2 ^ toℕ h)
lvlOfsuc : ∀ m → 0 < lvlOf (suc m)
lvlOfsuc m with even? (suc m)
...| yes _ = s≤s z≤n
...| no _ = s≤s z≤n
-- This proves that ℕ makes a skiplog dependency relation
-- by connecting the indexes by their largest power of two.
skiplog-dep-rel : DepRel
skiplog-dep-rel = record
{ lvlof = lvlOf
; lvlof-z = refl
; lvlof-s = lvlOfsuc
; hop-tgt = λ {m} h → m ∸ 2 ^ toℕ h
; hop-tgt-inj = λ {m} {h} {h'} prf
→ toℕ-injective (2^-injective {toℕ h} {toℕ h'}
(∸-inj (2 ^ toℕ h) (2 ^ toℕ h')
(lvlOf-correct (toℕ<n h))
(lvlOf-correct (toℕ<n h'))
prf))
; hop-< = λ h → ≤∧≢⇒< (hop-≤ h) (hop-prog h)
; hops-nested-or-nonoverlapping
= λ {h₁} {h₂} {h₃} {h₄} a b
→ no-overlap-< (getHop h₃) (getHop h₄) a b
}
-- This, in turn, enables us to bring the abstract module into
-- scope with everything instantiated minus the hash functions.
module _
(hash : ByteString → Hash)
(hash-cr : ∀{x y} → hash x ≡ hash y → Collision hash x y ⊎ x ≡ y)
where
open import AAOSL.Abstract.Advancement hash hash-cr encodeℕ encodeℕ-inj skiplog-dep-rel
open import AAOSL.Abstract.EvoCR hash hash-cr encodeℕ encodeℕ-inj skiplog-dep-rel
|
pcl/edsger_lib/stdio/writer.asm | johnp41/Compiler-Uni | 0 | 146 | ; void writeReal (double d);
; --------------------------
; This function prints a real number to the standard output.
section .code
global _writeReal
extern _formatReal
extern _writeString
_writeReal:
push rbp
mov rbp, rsp
push rdi
push rsi
movupd xmm0, [rbp+16]
mov r8, 0x00050000
lea rdi, [buffer]
call _formatReal
lea rdi, [buffer]
call _writeString
pop rsi
pop rdi
pop rbp
ret
section .bss
buffer resb 32
|
oeis/064/A064951.asm | neoneye/loda-programs | 11 | 171798 | ; A064951: Sum of lcm(x, y) for 1 <= x, y <= n.
; Submitted by <NAME>(s1)
; 1,7,28,72,177,303,604,948,1497,2127,3348,4272,6313,8119,10324,13060,17701,20995,27512,32132,38453,45779,57440,64664,77689,89935,104704,117948,141525,154755,183616,205472,231113,258959,290564,314720,364041,403143,446004,482124,549405,587331,665032,718756,776401,846367,948028,1005484,1108433,1186583,1284044,1373848,1519969,1608583,1736788,1840332,1977189,2118651,2320608,2417628,2640949,2814115,2979364,3154148,3368453,3522299,3818640,4022844,4267725,4457355,4810296,4999152,5382913,5678839,5952364
mov $3,2
add $3,$0
lpb $3
mov $0,$5
sub $3,1
add $0,$3
trn $0,1
seq $0,57660 ; a(n) = Sum_{k=1..n} n/gcd(n,k).
mov $2,$3
mul $2,$0
add $4,$2
lpe
mov $0,$4
|
oeis/291/A291016.asm | neoneye/loda-programs | 11 | 102903 | <filename>oeis/291/A291016.asm
; A291016: p-INVERT of (1,1,1,1,1,...), where p(S) = 1 - 4 S + S^2.
; 4,19,90,426,2016,9540,45144,213624,1010880,4783536,22635936,107114400,506870784,2398538304,11350005120,53708800896,254152774656,1202663842560,5691066407424,26930415389184,127436093890560,603034071008256,2853587862706176,13503322750187520,63898409324888064,302370519448203264,1430832660739891200,6770772847750127616,32039641122061418496,151613209645867745280,717441411142837960704,3394969208981821292544,16065166787033899991040,76021185468312472190976,359736112087671433199616
mov $1,4
mov $3,5
lpb $0
sub $0,1
mul $1,6
mov $2,$1
sub $1,$3
mov $3,$2
lpe
mov $0,$1
|
Rows/Rows.g4 | liuwenzhuang/learn-antlr | 0 | 2171 | grammar Rows;
@parser::members { // add members to generated RowsParser
protected col: number;
public setCol(num: number) {
this.col = num;
}
}
file: (row NL)+ ;
row
locals [number i=0]
: ( STUFF
{
$i++;
if ( $i == this.col ) console.log($STUFF.text);
}
)+
;
TAB : '\t' -> skip ; // match but don't pass to the parser
NL : '\r'? '\n' ; // match and pass to the parser
STUFF: ~[\t\r\n]+ ; // match any chars except tab, newline
|
test/Succeed/Issue3544.agda | Forty-Bot/agda | 0 | 9667 | <filename>test/Succeed/Issue3544.agda
data Nat : Set where
succ : Nat → Nat
data Fin : Nat → Set where
zero : (n : Nat) → Fin (succ n)
data Tm (n : Nat) : Set where
var : Fin n → Tm n
piv : Fin (succ n) → Tm n
data Cx : Nat → Set where
succ : (n : Nat) → Tm n → Cx (succ n)
data CxChk : ∀ n → Cx n → Set where
succ : (n : Nat) (T : Tm n) → CxChk (succ n) (succ n T)
data TmChk (n : Nat) : Cx n → Tm n → Set where
vtyp : (g : Cx n) (v : Fin n) → CxChk n g → TmChk n g (var v)
error : ∀ n g s → TmChk n g s → Set
error n g s (vtyp g' (zero x) (succ n' (piv (zero y)))) = Nat -- Internal error here.
error _ _ _ (vtyp g' (zero n) (succ n (var x))) = Nat -- This clause added to pass 2.5.3.
|
ppl/src/main/antlr/OpenDistroPPLLexer.g4 | pakio/sql | 0 | 2470 | /*
* Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file. This file 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.
*/
lexer grammar OpenDistroPPLLexer;
channels { WHITESPACE, ERRORCHANNEL }
// COMMAND KEYWORDS
SEARCH: 'SEARCH';
FROM: 'FROM';
WHERE: 'WHERE';
FIELDS: 'FIELDS';
RENAME: 'RENAME';
STATS: 'STATS';
DEDUP: 'DEDUP';
SORT: 'SORT';
EVAL: 'EVAL';
HEAD: 'HEAD';
TOP: 'TOP';
RARE: 'RARE';
// COMMAND ASSIST KEYWORDS
AS: 'AS';
BY: 'BY';
SOURCE: 'SOURCE';
INDEX: 'INDEX';
D: 'D';
DESC: 'DESC';
// CLAUSE KEYWORDS
SORTBY: 'SORTBY';
// FIELD KEYWORDS
AUTO: 'AUTO';
STR: 'STR';
IP: 'IP';
NUM: 'NUM';
// ARGUMENT KEYWORDS
KEEPEMPTY: 'KEEPEMPTY';
KEEPLAST: 'KEEPLAST';
CONSECUTIVE: 'CONSECUTIVE';
DEDUP_SPLITVALUES: 'DEDUP_SPLITVALUES';
PARTITIONS: 'PARTITIONS';
ALLNUM: 'ALLNUM';
DELIM: 'DELIM';
WHILE: 'WHILE';
// COMPARISON FUNCTION KEYWORDS
CASE: 'CASE';
IN: 'IN';
// LOGICAL KEYWORDS
NOT: 'NOT';
OR: 'OR';
AND: 'AND';
XOR: 'XOR';
TRUE: 'TRUE';
FALSE: 'FALSE';
LIKE: 'LIKE';
REGEXP: 'REGEXP';
// DATETIME, INTERVAL AND UNIT KEYWORDS
DATETIME: 'DATETIME';
INTERVAL: 'INTERVAL';
MICROSECOND: 'MICROSECOND';
SECOND: 'SECOND';
MINUTE: 'MINUTE';
HOUR: 'HOUR';
DAY: 'DAY';
WEEK: 'WEEK';
MONTH: 'MONTH';
QUARTER: 'QUARTER';
YEAR: 'YEAR';
SECOND_MICROSECOND: 'SECOND_MICROSECOND';
MINUTE_MICROSECOND: 'MINUTE_MICROSECOND';
MINUTE_SECOND: 'MINUTE_SECOND';
HOUR_MICROSECOND: 'HOUR_MICROSECOND';
HOUR_SECOND: 'HOUR_SECOND';
HOUR_MINUTE: 'HOUR_MINUTE';
DAY_MICROSECOND: 'DAY_MICROSECOND';
DAY_SECOND: 'DAY_SECOND';
DAY_MINUTE: 'DAY_MINUTE';
DAY_HOUR: 'DAY_HOUR';
YEAR_MONTH: 'YEAR_MONTH';
// DATASET TYPES
DATAMODEL: 'DATAMODEL';
LOOKUP: 'LOOKUP';
SAVEDSEARCH: 'SAVEDSEARCH';
// SPECIAL CHARACTERS AND OPERATORS
PIPE: '|';
COMMA: ',';
DOT: '.';
EQUAL: '=';
GREATER: '>';
LESS: '<';
NOT_GREATER: '<' '=';
NOT_LESS: '>' '=';
NOT_EQUAL: '!' '=';
PLUS: '+';
MINUS: '-';
STAR: '*';
DIVIDE: '/';
MODULE: '%';
EXCLAMATION_SYMBOL: '!';
COLON: ':';
LT_PRTHS: '(';
RT_PRTHS: ')';
LT_SQR_PRTHS: '[';
RT_SQR_PRTHS: ']';
SINGLE_QUOTE: '\'';
DOUBLE_QUOTE: '"';
BACKTICK: '`';
// AGGREGATIONS
AVG: 'AVG';
COUNT: 'COUNT';
DISTINCT_COUNT: 'DISTINCT_COUNT';
ESTDC: 'ESTDC';
ESTDC_ERROR: 'ESTDC_ERROR';
MAX: 'MAX';
MEAN: 'MEAN';
MEDIAN: 'MEDIAN';
MIN: 'MIN';
MODE: 'MODE';
RANGE: 'RANGE';
STDEV: 'STDEV';
STDEVP: 'STDEVP';
SUM: 'SUM';
SUMSQ: 'SUMSQ';
VAR: 'VAR';
VARP: 'VARP';
PERCENTILE: 'PERCENTILE';
FIRST: 'FIRST';
LAST: 'LAST';
LIST: 'LIST';
VALUES: 'VALUES';
EARLIEST: 'EARLIEST';
EARLIEST_TIME: 'EARLIEST_TIME';
LATEST: 'LATEST';
LATEST_TIME: 'LATEST_TIME';
PER_DAY: 'PER_DAY';
PER_HOUR: 'PER_HOUR';
PER_MINUTE: 'PER_MINUTE';
PER_SECOND: 'PER_SECOND';
RATE: 'RATE';
SPARKLINE: 'SPARKLINE';
C: 'C';
DC: 'DC';
// BASIC FUNCTIONS
ABS: 'ABS';
CEIL: 'CEIL';
CEILING: 'CEILING';
CONV: 'CONV';
CRC32: 'CRC32';
E: 'E';
EXP: 'EXP';
FLOOR: 'FLOOR';
LN: 'LN';
LOG: 'LOG';
LOG10: 'LOG10';
LOG2: 'LOG2';
MOD: 'MOD';
PI: 'PI';
POW: 'POW';
POWER: 'POWER';
RAND: 'RAND';
ROUND: 'ROUND';
SIGN: 'SIGN';
SQRT: 'SQRT';
TRUNCATE: 'TRUNCATE';
// TRIGONOMETRIC FUNCTIONS
ACOS: 'ACOS';
ASIN: 'ASIN';
ATAN: 'ATAN';
ATAN2: 'ATAN2';
COS: 'COS';
COT: 'COT';
DEGREES: 'DEGREES';
RADIANS: 'RADIANS';
SIN: 'SIN';
TAN: 'TAN';
// DATE AND TIME FUNCTIONS
ADDDATE: 'ADDDATE';
DATE: 'DATE';
DATE_ADD: 'DATE_ADD';
DATE_SUB: 'DATE_SUB';
DAYOFMONTH: 'DAYOFMONTH';
DAYOFWEEK: 'DAYOFWEEK';
DAYOFYEAR: 'DAYOFYEAR';
DAYNAME: 'DAYNAME';
FROM_DAYS: 'FROM_DAYS';
MONTHNAME: 'MONTHNAME';
SUBDATE: 'SUBDATE';
TIME: 'TIME';
TIME_TO_SEC: 'TIME_TO_SEC';
TIMESTAMP: 'TIMESTAMP';
DATE_FORMAT: 'DATE_FORMAT';
TO_DAYS: 'TO_DAYS';
// TEXT FUNCTIONS
SUBSTR: 'SUBSTR';
SUBSTRING: 'SUBSTRING';
LTRIM: 'LTRIM';
RTRIM: 'RTRIM';
TRIM: 'TRIM';
TO: 'TO';
LOWER: 'LOWER';
UPPER: 'UPPER';
CONCAT: 'CONCAT';
CONCAT_WS: 'CONCAT_WS';
LENGTH: 'LENGTH';
STRCMP: 'STRCMP';
// LITERALS AND VALUES
//STRING_LITERAL: DQUOTA_STRING | SQUOTA_STRING | BQUOTA_STRING;
ID: ID_LITERAL;
INTEGER_LITERAL: DEC_DIGIT+;
DECIMAL_LITERAL: (DEC_DIGIT+)? '.' DEC_DIGIT+;
fragment ID_LITERAL: [A-Z_]+[A-Z_$0-9@\-]*;
DQUOTA_STRING: '"' ( '\\'. | '""' | ~('"'| '\\') )* '"';
SQUOTA_STRING: '\'' ('\\'. | '\'\'' | ~('\'' | '\\'))* '\'';
BQUOTA_STRING: '`' ( '\\'. | '``' | ~('`'|'\\'))* '`';
fragment DEC_DIGIT: [0-9];
ERROR_RECOGNITION: . -> channel(ERRORCHANNEL); |
data/maps/objects/RedsHouse2F.asm | opiter09/ASM-Machina | 1 | 241098 | RedsHouse2F_Object:
db $a ; border block
def_warps
warp 7, 1, 2, REDS_HOUSE_1F
def_signs
def_objects
def_warps_to REDS_HOUSE_2F
|
rts/gcc-8/adainclude/s-secsta.ads | letsbyteit/build-avr-ada-toolchain | 7 | 12410 | <gh_stars>1-10
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- S Y S T E M . S E C O N D A R Y _ S T A C K --
-- --
-- S p e c --
-- --
-- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
-- --
-- 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. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- 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 was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This version is a simplified edition of the original
-- System.Secondary_Stack from gcc-4.7 for use in single threaded AVR
-- applications.
with System.Storage_Elements;
package System.Secondary_Stack is
package SSE renames System.Storage_Elements;
Default_Secondary_Stack_Size : constant := 512;
-- Default size of a secondary stack
procedure SS_Init
(Stk : System.Address;
Size : Natural := Default_Secondary_Stack_Size);
-- Initialize the secondary stack with a main stack of the given Size.
procedure SS_Allocate
(Address : out System.Address;
Storage_Size : SSE.Storage_Count);
-- Allocate enough space for a 'Storage_Size' bytes object with Maximum
-- alignment. The address of the allocated space is returned in 'Address'
type Mark_Id is private;
-- Type used to mark the stack for mark/release processing
function SS_Mark return Mark_Id;
-- Return the Mark corresponding to the current state of the stack
procedure SS_Release (M : Mark_Id);
-- Restore the state of the stack corresponding to the mark M. If an
-- additional chunk have been allocated, it will never be freed during a
private
SS_Pool : Integer;
-- Unused entity that is just present to ease the sharing of the pool
-- mechanism for specific allocation/deallocation in the compiler
type Mark_Id is new SSE.Integer_Address;
end System.Secondary_Stack;
|
src/slots/test.agda | semenov-vladyslav/slots-agda | 0 | 103 | <reponame>semenov-vladyslav/slots-agda
module slots.test where
open import slots.imports
open import slots.defs using (config ; game)
open import slots.bruteforce using (rtp)
c : config
c = record { n = 3 ; m = 4 }
g : game c
g = record { reels = reels ; winTable = winTable } where
open config c
reel : Reel
reel = # 1 ∷ # 1 ∷ # 1 ∷ # 0 ∷ []
reel′ : Reel
reel′ = # 1 ∷ # 1 ∷ # 2 ∷ # 0 ∷ []
reel″ : Reel
reel″ = # 1 ∷ # 3 ∷ # 1 ∷ # 0 ∷ []
reels : Reels
reels =
reel ∷
reel′ ∷
reel″ ∷
[]
winTable : WinTable
winTable =
(0 ∷ 0 ∷ 0 ∷ []) ∷
(0 ∷ 1 ∷ 2 ∷ []) ∷
(0 ∷ 0 ∷ 0 ∷ []) ∷
(0 ∷ 0 ∷ 0 ∷ []) ∷
[]
% : ℕ × ℕ
% = rtp g
%-prf : % ≡ (36 , 64)
%-prf = refl
|
src/dbase-scroller.ads | zenharris/ada-bbs | 2 | 106 | <gh_stars>1-10
with gnatcoll.SQL.Postgres; use gnatcoll.SQL.Postgres;
with gnatcoll.SQL.Exec; use gnatcoll.SQL.Exec;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Vectors;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
with Ada.Text_IO.Unbounded_IO;
with Formatter;
with Ada.Containers.Doubly_Linked_Lists;
with Ada.Containers; use Ada.Containers;
with Terminal_Interface.Curses; use Terminal_Interface.Curses;
with Ada.Characters.Latin_1; use Ada.Characters.Latin_1;
with GNAT.Regpat; use GNAT.Regpat;
-- with Templates;
-- with Dbase.DrackSpace;
with Ada.Numerics.Generic_Elementary_Functions;
package Dbase.Scroller is
package SU renames Ada.Strings.Unbounded;
package SUIO renames Ada.Text_IO.Unbounded_IO;
type Scrl_Record is record
ID : Integer;
Prompt : Unbounded_String;
-- Func : Function_Access;
end record;
package Scrl_List is new Ada.Containers.Doubly_Linked_Lists(Scrl_Record);
use Scrl_List;
-- package Drack is new Dbase.DrackSpace;
Radar_Mode : Boolean := False;
subtype Value_Type is Long_Long_Float;
package Value_Functions is new Ada.Numerics.Generic_Elementary_Functions (
Value_Type);
use Value_Functions;
Definition_Ptr : Integer := 1;
function Fld (CI : Direct_Cursor; FldNme : Unbounded_String) return String;
function OpenDb return Boolean;
procedure CloseDb;
procedure Scroll (L_AckStatement : String; Down : Integer := 0; Left : Integer := 0; AltFunctions : Boolean := False); --; CI : in out Direct_Cursor);
procedure Run;
end Dbase.Scroller;
|
programs/oeis/305/A305164.asm | karttu/loda | 1 | 166072 | ; A305164: a(n) = 28*2^n - 22.
; 6,34,90,202,426,874,1770,3562,7146,14314,28650,57322,114666,229354,458730,917482,1834986,3669994,7340010,14680042,29360106,58720234,117440490,234881002,469762026,939524074,1879048170,3758096362,7516192746,15032385514,30064771050,60129542122,120259084266,240518168554
mov $1,2
pow $1,$0
sub $1,1
mul $1,28
add $1,6
|
test/interaction/Issue2236.agda | shlevy/agda | 1,989 | 6642 | <gh_stars>1000+
-- Andreas, 2016-10-04, issue #2236
-- Result splitting should not insert hidden arguments visibly
-- {-# OPTIONS -v interaction.case:100 #-}
-- {-# OPTIONS -v tc.cover:100 #-}
-- {-# OPTIONS -v reify.clause:100 #-}
-- {-# OPTIONS -v reify.implicit:100 #-}
splitMe : (A : Set) {B : Set} → Set
splitMe = {!!} -- C-c C-c RET inserts hidden {B}
splitMe' : (A : Set) {B : Set} (C : Set) {D : Set} → Set
splitMe' = {!!} -- C-c C-c RET inserts hidden {B} and {D}
splitMe'' : {B : Set} (C : Set) {D : Set} → Set
splitMe'' = {!!} -- C-c C-c RET inserts hidden {D}
postulate
N : Set
P : N → Set
test : (A : Set) → ∀ {n} → P n → Set
test = {!!} -- C-c C-c RET inserts hidden {n}
-- Correct is:
-- No hidden arguments inserted on lhs.
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/unchecked_convert3.adb | best08618/asylo | 7 | 22960 | -- { dg-do run }
-- { dg-options "-gnatVa" }
with Unchecked_Conversion;
procedure Unchecked_Convert3 is
type Word is range -(2**15) .. (2**15) - 1;
type UWord is mod (2**16);
function To_Word is new unchecked_conversion (UWord, Word);
function F return UWord is
begin
return 65036;
end;
W : Word := To_Word(F);
begin
null;
end;
|
src/vt100-utils.adb | darkestkhan/vt100 | 8 | 1308 | ------------------------------------------------------------------------------
-- EMAIL: <<EMAIL>> --
-- License: ISC License (see COPYING file) --
-- --
-- Copyright © 2012 - 2015 darkestkhan --
------------------------------------------------------------------------------
-- 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.Environment_Variables;
package body VT100.Utils is
---------------
-- L I N E S --
---------------
function Lines return Natural
is
begin
if Ada.Environment_Variables.Exists ("LINES") then
return Natural'Value (Ada.Environment_Variables.Value (Name => "LINES"));
else
return 0;
end if;
end Lines;
-------------------
-- C O L U M N S --
-------------------
function Columns return Natural
is
begin
if Ada.Environment_Variables.Exists ("COLUMNS") then
return Natural'Value (Ada.Environment_Variables.Value
(Name => "COLUMNS"));
else
return 0;
end if;
end Columns;
end VT100.Utils;
|
src/words_engine/words_engine-tricks.ads | spr93/whitakers-words | 204 | 15280 | <gh_stars>100-1000
-- WORDS, a Latin dictionary, by <NAME> (USAF, Retired)
--
-- Copyright <NAME> (1936–2010)
--
-- This is a free program, which means it is proper to copy it and pass
-- it on to your friends. Consider it a developmental item for which
-- there is no charge. However, just for form, it is Copyrighted
-- (c). Permission is hereby freely given for any and all use of program
-- and data. You can sell it as your own, but at least tell me.
--
-- This version is distributed without obligation, but the developer
-- would appreciate comments and suggestions.
--
-- All parts of the WORDS system, source code and data files, are made freely
-- available to anyone who wishes to use them, for whatever purpose.
with Latin_Utils.Dictionary_Package; use Latin_Utils.Dictionary_Package;
with Words_Engine.Explanation_Package; use Words_Engine.Explanation_Package;
package Words_Engine.Tricks is
procedure Syncope
(W : String;
Pa : in out Parse_Array;
Pa_Last : in out Integer;
Xp : in out Explanations);
procedure Try_Tricks
(W : String;
Pa : in out Parse_Array;
Pa_Last : in out Integer;
Line_Number : Integer;
Word_Number : Integer;
Xp : in out Explanations);
procedure Try_Slury
(W : String;
Pa : in out Parse_Array;
Pa_Last : in out Integer;
Line_Number : Integer;
Word_Number : Integer;
Xp : in out Explanations);
procedure Roman_Numerals
(Input_Word : String;
Pa : in out Parse_Array;
Pa_Last : in out Integer;
Xp : in out Explanations);
end Words_Engine.Tricks;
|
test/Fail/Issue1209-3.agda | caryoscelus/agda | 0 | 8656 | <filename>test/Fail/Issue1209-3.agda
-- This combination should not be allowed:
{-# OPTIONS --guardedness --sized-types --safe #-}
|
assets/as2.applescript | doekman/osagitfilter | 29 | 2582 | #@osa-lang:AppleScript
on run (arg)
log "Doesn't end with an empty line"
end run |
cards/bn4/ModCards/134-E005 MAX HP +650 (0E).asm | RockmanEXEZone/MMBN-Mod-Card-Kit | 10 | 16141 | .include "defaults_mod.asm"
table_file_jp equ "exe4-utf8.tbl"
table_file_en equ "bn4-utf8.tbl"
game_code_len equ 3
game_code equ 0x4234574A // B4WJ
game_code_2 equ 0x42345745 // B4WE
game_code_3 equ 0x42345750 // B4WP
card_type equ 1
card_id equ 65
card_no equ "065"
card_sub equ "Mod Card 065"
card_sub_x equ 64
card_desc_len equ 2
card_desc_1 equ "Address 0E"
card_desc_2 equ "MAX HP +650"
card_desc_3 equ ""
card_name_jp_full equ "マックスHP+650"
card_name_jp_game equ "マックスHP+650"
card_name_en_full equ "MAX HP +650"
card_name_en_game equ "MAX HP +650"
card_address equ "0E"
card_address_id equ 4
card_bug equ 0
card_wrote_en equ "MAX HP +650"
card_wrote_jp equ "マックスHP+650" |
programs/oeis/084/A084626.asm | neoneye/loda | 22 | 353 | <filename>programs/oeis/084/A084626.asm
; A084626: Floor(C(n+6,6)/C(n+2,2)).
; 1,2,4,8,14,22,33,47,66,91,121,158,204,258,323,399,487,590,708,843,996,1170,1365,1583,1827,2097,2397,2728,3091,3490,3927,4403,4921,5483,6092,6751,7462,8227,9050,9933,10879,11891,12972,14125,15353,16660,18048,19521,21083,22737,24486,26334,28284,30341,32509,34790,37189,39711,42358,45136,48048,51098,54292,57633,61126,64775,68586,72562,76708,81030,85531,90218,95095,100166,105438,110916,116604,122508,128633,134985,141570,148393,155459,162775,170346,178178,186277,194649,203300,212236,221464,230989,240818,250958,261415,272195,283305,294751,306541,318682
add $0,6
bin $0,4
div $0,15
|
include/sf-network-socketselector.ads | Fabien-Chouteau/ASFML | 0 | 2560 | <reponame>Fabien-Chouteau/ASFML<gh_stars>0
--//////////////////////////////////////////////////////////
-- SFML - Simple and Fast Multimedia Library
-- Copyright (C) 2007-2015 <NAME> (<EMAIL>)
-- This software is provided 'as-is', without any express or implied warranty.
-- In no event will the authors be held liable for any damages arising from the use of this software.
-- Permission is granted to anyone to use this software for any purpose,
-- including commercial applications, and to alter it and redistribute it freely,
-- subject to the following restrictions:
-- 1. The origin of this software must not be misrepresented;
-- you must not claim that you wrote the original software.
-- If you use this software in a product, an acknowledgment
-- in the product documentation would be appreciated but is not required.
-- 2. Altered source versions must be plainly marked as such,
-- and must not be misrepresented as being the original software.
-- 3. This notice may not be removed or altered from any source distribution.
--//////////////////////////////////////////////////////////
--//////////////////////////////////////////////////////////
with Sf.System.Time;
package Sf.Network.SocketSelector is
--//////////////////////////////////////////////////////////
--/ @brief Create a new selector
--/
--/ @return A new sfSocketSelector object
--/
--//////////////////////////////////////////////////////////
function create return sfSocketSelector_Ptr;
--//////////////////////////////////////////////////////////
--/ @brief Create a new socket selector by copying an existing one
--/
--/ @param selector Socket selector to copy
--/
--/ @return A new sfSocketSelector object which is a copy of @a selector
--/
--//////////////////////////////////////////////////////////
function copy (selector : sfSocketSelector_Ptr) return sfSocketSelector_Ptr;
--//////////////////////////////////////////////////////////
--/ @brief Destroy a socket selector
--/
--/ @param selector Socket selector to destroy
--/
--//////////////////////////////////////////////////////////
procedure destroy (selector : sfSocketSelector_Ptr);
--//////////////////////////////////////////////////////////
--/ @brief Add a new socket to a socket selector
--/
--/ This function keeps a weak pointer to the socket,
--/ so you have to make sure that the socket is not destroyed
--/ while it is stored in the selector.
--/
--/ @param selector Socket selector object
--/ @param socket Pointer to the socket to add
--/
--//////////////////////////////////////////////////////////
procedure addTcpListener (selector : sfSocketSelector_Ptr; socket : sfTcpListener_Ptr);
procedure addTcpSocket (selector : sfSocketSelector_Ptr; socket : sfTcpSocket_Ptr);
procedure addUdpSocket (selector : sfSocketSelector_Ptr; socket : sfUdpSocket_Ptr);
--//////////////////////////////////////////////////////////
--/ @brief Remove a socket from a socket selector
--/
--/ This function doesn't destroy the socket, it simply
--/ removes the pointer that the selector has to it.
--/
--/ @param selector Socket selector object
--/ @param socket POointer to the socket to remove
--/
--//////////////////////////////////////////////////////////
procedure removeTcpListener (selector : sfSocketSelector_Ptr; socket : sfTcpListener_Ptr);
procedure removeTcpSocket (selector : sfSocketSelector_Ptr; socket : sfTcpSocket_Ptr);
procedure removeUdpSocket (selector : sfSocketSelector_Ptr; socket : sfUdpSocket_Ptr);
--//////////////////////////////////////////////////////////
--/ @brief Remove all the sockets stored in a selector
--/
--/ This function doesn't destroy any instance, it simply
--/ removes all the pointers that the selector has to
--/ external sockets.
--/
--/ @param selector Socket selector object
--/
--//////////////////////////////////////////////////////////
procedure clear (selector : sfSocketSelector_Ptr);
--//////////////////////////////////////////////////////////
--/ @brief Wait until one or more sockets are ready to receive
--/
--/ This function returns as soon as at least one socket has
--/ some data available to be received. To know which sockets are
--/ ready, use the sfSocketSelector_isXxxReady functions.
--/ If you use a timeout and no socket is ready before the timeout
--/ is over, the function returns sfFalse.
--/
--/ @param selector Socket selector object
--/ @param timeout Maximum time to wait (use sfTimeZero for infinity)
--/
--/ @return sfTrue if there are sockets ready, sfFalse otherwise
--/
--//////////////////////////////////////////////////////////
function wait (selector : sfSocketSelector_Ptr; timeout : Sf.System.Time.sfTime) return sfBool;
--//////////////////////////////////////////////////////////
--/ @brief Test a socket to know if it is ready to receive data
--/
--/ This function must be used after a call to
--/ sfSocketSelector_wait, to know which sockets are ready to
--/ receive data. If a socket is ready, a call to Receive will
--/ never block because we know that there is data available to read.
--/ Note that if this function returns sfTrue for a sfTcpListener,
--/ this means that it is ready to accept a new connection.
--/
--/ @param selector Socket selector object
--/ @param socket Socket to test
--/
--/ @return sfTrue if the socket is ready to read, sfFalse otherwise
--/
--//////////////////////////////////////////////////////////
function isTcpListenerReady (selector : sfSocketSelector_Ptr; socket : sfTcpListener_Ptr) return sfBool;
function isTcpSocketReady (selector : sfSocketSelector_Ptr; socket : sfTcpSocket_Ptr) return sfBool;
function isUdpSocketReady (selector : sfSocketSelector_Ptr; socket : sfTcpSocket_Ptr) return sfBool;
private
pragma Import (C, create, "sfSocketSelector_create");
pragma Import (C, copy, "sfSocketSelector_copy");
pragma Import (C, destroy, "sfSocketSelector_destroy");
pragma Import (C, addTcpListener, "sfSocketSelector_addTcpListener");
pragma Import (C, addTcpSocket, "sfSocketSelector_addTcpSocket");
pragma Import (C, addUdpSocket, "sfSocketSelector_addUdpSocket");
pragma Import (C, removeTcpListener, "sfSocketSelector_removeTcpListener");
pragma Import (C, removeTcpSocket, "sfSocketSelector_removeTcpSocket");
pragma Import (C, removeUdpSocket, "sfSocketSelector_removeUdpSocket");
pragma Import (C, clear, "sfSocketSelector_clear");
pragma Import (C, wait, "sfSocketSelector_wait");
pragma Import (C, isTcpListenerReady, "sfSocketSelector_isTcpListenerReady");
pragma Import (C, isTcpSocketReady, "sfSocketSelector_isTcpSocketReady");
pragma Import (C, isUdpSocketReady, "sfSocketSelector_isUdpSocketReady");
end Sf.Network.SocketSelector;
|
src/gdnative.adb | persan/gdnative_ada | 10 | 3227 | package body GDNative is
------------
-- To Str --
------------
function To_Str (S : Wide_String) return String is
Result : String (S'first .. S'last);
begin
for I in S'range loop Result (I) := Character'val (Wide_Character'pos (S (I))); end loop;
return Result;
end;
-------------
-- To Wide --
-------------
function To_Wide (S : String) return Wide_String is
Result : Wide_String (S'first .. S'last);
begin
for I in S'range loop Result (I) := Wide_Character'val (Character'pos (S (I))); end loop;
return Result;
end;
end; |
fiat-amd64/394.42_ratio08680_seed2529639215636402_mul_p434.asm | dderjoel/fiat-crypto | 491 | 161487 | <gh_stars>100-1000
SECTION .text
GLOBAL mul_p434
mul_p434:
sub rsp, 0x4b0 ; last 0x30 (6) for Caller - save regs
mov [ rsp + 0x480 ], rbx; saving to stack
mov [ rsp + 0x488 ], rbp; saving to stack
mov [ rsp + 0x490 ], r12; saving to stack
mov [ rsp + 0x498 ], r13; saving to stack
mov [ rsp + 0x4a0 ], r14; saving to stack
mov [ rsp + 0x4a8 ], r15; saving to stack
mov rax, [ rsi + 0x0 ]; load m64 x7 to register64
xchg rdx, rax; x7, swapping with arg2, which is currently in rdx
mulx r10, r11, [ rax + 0x0 ]; x21, x20<- x7 * arg2[0]
mov rbx, 0xffffffffffffffff ; moving imm to reg
xchg rdx, rbx; 0xffffffffffffffff, swapping with x7, which is currently in rdx
mulx rbp, r12, r11; x48, x47<- x20 * 0xffffffffffffffff
xor r13, r13
adox r12, r11
mov r12, rdx; preserving value of 0xffffffffffffffff into a new reg
mov rdx, [ rax + 0x8 ]; saving arg2[1] in rdx.
mulx r14, r15, rbx; x19, x18<- x7 * arg2[1]
adcx r15, r10
mov rdx, r12; 0xffffffffffffffff to rdx
mulx r12, rcx, r11; x46, x45<- x20 * 0xffffffffffffffff
setc r8b; spill CF x23 to reg (r8)
clc;
adcx rcx, rbp
adox rcx, r15
mov r9, [ rsi + 0x8 ]; load m64 x1 to register64
mov r10, rdx; preserving value of 0xffffffffffffffff into a new reg
mov rdx, [ rax + 0x0 ]; saving arg2[0] in rdx.
mulx rbp, r15, r9; x91, x90<- x1 * arg2[0]
seto r10b; spill OF x65 to reg (r10)
mov [ rsp + 0x0 ], rdi; spilling out1 to mem
mov rdi, -0x3 ; moving imm to reg
inc rdi; OF<-0x0, preserve CF (debug 7; load -3, increase it, save it as -2). #last resort
adox r15, rcx
mov rcx, 0xffffffffffffffff ; moving imm to reg
mov rdx, r15; x105 to rdx
mulx r15, r13, rcx; x134, x133<- x105 * 0xffffffffffffffff
mov [ rsp + 0x8 ], rbp; spilling x91 to mem
mulx rdi, rbp, rcx; x132, x131<- x105 * 0xffffffffffffffff
seto cl; spill OF x106 to reg (rcx)
mov byte [ rsp + 0x10 ], r10b; spilling byte x65 to mem
mov r10, -0x2 ; moving imm to reg
inc r10; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox rbp, r15
mov r15, 0xffffffffffffffff ; moving imm to reg
mov [ rsp + 0x18 ], rbp; spilling x135 to mem
mulx r10, rbp, r15; x130, x129<- x105 * 0xffffffffffffffff
adox rbp, rdi
mov rdi, 0xfdc1767ae2ffffff ; moving imm to reg
mov [ rsp + 0x20 ], rbp; spilling x137 to mem
mulx r15, rbp, rdi; x128, x127<- x105 * 0xfdc1767ae2ffffff
adox rbp, r10
mov r10, 0x7bc65c783158aea3 ; moving imm to reg
mov [ rsp + 0x28 ], rbp; spilling x139 to mem
mulx rdi, rbp, r10; x126, x125<- x105 * 0x7bc65c783158aea3
adox rbp, r15
mov r15, 0x6cfc5fd681c52056 ; moving imm to reg
mov [ rsp + 0x30 ], rbp; spilling x141 to mem
mulx r10, rbp, r15; x124, x123<- x105 * 0x6cfc5fd681c52056
adox rbp, rdi
mov rdi, 0x2341f27177344 ; moving imm to reg
mov [ rsp + 0x38 ], rbp; spilling x143 to mem
mulx r15, rbp, rdi; x122, x121<- x105 * 0x2341f27177344
adox rbp, r10
mov r10, [ rsi + 0x10 ]; load m64 x2 to register64
mov rdi, 0x0 ; moving imm to reg
adox r15, rdi
xchg rdx, r10; x2, swapping with x105, which is currently in rdx
mov [ rsp + 0x40 ], r15; spilling x147 to mem
mulx rdi, r15, [ rax + 0x0 ]; x178, x177<- x2 * arg2[0]
mov [ rsp + 0x48 ], rbp; spilling x145 to mem
mov [ rsp + 0x50 ], r15; spilling x177 to mem
mulx rbp, r15, [ rax + 0x8 ]; x176, x175<- x2 * arg2[1]
mov byte [ rsp + 0x58 ], cl; spilling byte x106 to mem
mov rcx, -0x2 ; moving imm to reg
inc rcx; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r15, rdi
mulx rdi, rcx, [ rax + 0x10 ]; x174, x173<- x2 * arg2[2]
mov [ rsp + 0x60 ], r15; spilling x179 to mem
mov [ rsp + 0x68 ], r9; spilling x1 to mem
mulx r15, r9, [ rax + 0x18 ]; x172, x171<- x2 * arg2[3]
adox rcx, rbp
mov [ rsp + 0x70 ], rcx; spilling x181 to mem
mulx rbp, rcx, [ rax + 0x20 ]; x170, x169<- x2 * arg2[4]
adox r9, rdi
mov [ rsp + 0x78 ], r9; spilling x183 to mem
mulx rdi, r9, [ rax + 0x28 ]; x168, x167<- x2 * arg2[5]
adox rcx, r15
adox r9, rbp
mulx rdx, r15, [ rax + 0x30 ]; x166, x165<- x2 * arg2[6]
adox r15, rdi
seto bpl; spill OF x190 to reg (rbp)
mov rdi, -0x2 ; moving imm to reg
inc rdi; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r13, r10
movzx r13, bpl; x191, copying x190 here, cause x190 is needed in a reg for other than x191, namely all: , x191, size: 1
lea r13, [ r13 + rdx ]
mov rdx, rbx; x7 to rdx
mulx rbx, r10, [ rax + 0x10 ]; x17, x16<- x7 * arg2[2]
mov rbp, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r11; x20, swapping with x7, which is currently in rdx
mov [ rsp + 0x80 ], r13; spilling x191 to mem
mulx rdi, r13, rbp; x44, x43<- x20 * 0xffffffffffffffff
setc bpl; spill CF x50 to reg (rbp)
clc;
mov [ rsp + 0x88 ], r15; spilling x189 to mem
mov r15, -0x1 ; moving imm to reg
movzx r8, r8b
adcx r8, r15; loading flag
adcx r14, r10
setc r8b; spill CF x25 to reg (r8)
clc;
movzx rbp, bpl
adcx rbp, r15; loading flag
adcx r12, r13
mov rbp, rdx; preserving value of x20 into a new reg
mov rdx, [ rax + 0x8 ]; saving arg2[1] in rdx.
mulx r10, r13, [ rsp + 0x68 ]; x89, x88<- x1 * arg2[1]
seto r15b; spill OF x149 to reg (r15)
mov [ rsp + 0x90 ], r9; spilling x187 to mem
movzx r9, byte [ rsp + 0x10 ]; load byte memx65 to register64
mov [ rsp + 0x98 ], rcx; spilling x185 to mem
mov rcx, 0x0 ; moving imm to reg
dec rcx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox r9, rcx; loading flag
adox r14, r12
setc r9b; spill CF x52 to reg (r9)
clc;
adcx r13, [ rsp + 0x8 ]
seto r12b; spill OF x67 to reg (r12)
movzx rcx, byte [ rsp + 0x58 ]; load byte memx106 to register64
mov [ rsp + 0xa0 ], r10; spilling x89 to mem
mov r10, -0x1 ; moving imm to reg
inc r10; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r10, -0x1 ; moving imm to reg
adox rcx, r10; loading flag
adox r14, r13
setc cl; spill CF x93 to reg (rcx)
clc;
movzx r15, r15b
adcx r15, r10; loading flag
adcx r14, [ rsp + 0x18 ]
seto r15b; spill OF x108 to reg (r15)
inc r10; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
adox r14, [ rsp + 0x50 ]
mov r13, 0xffffffffffffffff ; moving imm to reg
mov rdx, r14; x192 to rdx
mulx r14, r10, r13; x221, x220<- x192 * 0xffffffffffffffff
seto r13b; spill OF x193 to reg (r13)
mov [ rsp + 0xa8 ], r14; spilling x221 to mem
mov r14, -0x2 ; moving imm to reg
inc r14; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r10, rdx
mov r10, 0xfdc1767ae2ffffff ; moving imm to reg
xchg rdx, r10; 0xfdc1767ae2ffffff, swapping with x192, which is currently in rdx
mov byte [ rsp + 0xb0 ], r13b; spilling byte x193 to mem
mulx r14, r13, rbp; x42, x41<- x20 * 0xfdc1767ae2ffffff
mov [ rsp + 0xb8 ], r14; spilling x42 to mem
mov r14, rdx; preserving value of 0xfdc1767ae2ffffff into a new reg
mov rdx, [ rax + 0x18 ]; saving arg2[3] in rdx.
mov byte [ rsp + 0xc0 ], r15b; spilling byte x108 to mem
mov byte [ rsp + 0xc8 ], cl; spilling byte x93 to mem
mulx r15, rcx, r11; x15, x14<- x7 * arg2[3]
setc r14b; spill CF x151 to reg (r14)
clc;
mov [ rsp + 0xd0 ], r15; spilling x15 to mem
mov r15, -0x1 ; moving imm to reg
movzx r9, r9b
adcx r9, r15; loading flag
adcx rdi, r13
setc r9b; spill CF x54 to reg (r9)
clc;
movzx r8, r8b
adcx r8, r15; loading flag
adcx rbx, rcx
setc r8b; spill CF x27 to reg (r8)
clc;
movzx r12, r12b
adcx r12, r15; loading flag
adcx rbx, rdi
mov rdx, [ rsp + 0x68 ]; x1 to rdx
mulx r12, r13, [ rax + 0x10 ]; x87, x86<- x1 * arg2[2]
setc cl; spill CF x69 to reg (rcx)
movzx rdi, byte [ rsp + 0xc8 ]; load byte memx93 to register64
clc;
adcx rdi, r15; loading flag
adcx r13, [ rsp + 0xa0 ]
seto dil; spill OF x236 to reg (rdi)
movzx r15, byte [ rsp + 0xc0 ]; load byte memx108 to register64
mov [ rsp + 0xd8 ], r12; spilling x87 to mem
mov r12, 0x0 ; moving imm to reg
dec r12; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox r15, r12; loading flag
adox rbx, r13
setc r15b; spill CF x95 to reg (r15)
clc;
movzx r14, r14b
adcx r14, r12; loading flag
adcx rbx, [ rsp + 0x20 ]
seto r14b; spill OF x110 to reg (r14)
movzx r13, byte [ rsp + 0xb0 ]; load byte memx193 to register64
inc r12; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r12, -0x1 ; moving imm to reg
adox r13, r12; loading flag
adox rbx, [ rsp + 0x60 ]
mov r13, [ rsi + 0x18 ]; load m64 x3 to register64
mov r12, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r10; x192, swapping with x1, which is currently in rdx
mov byte [ rsp + 0xe0 ], r14b; spilling byte x110 to mem
mov byte [ rsp + 0xe8 ], r15b; spilling byte x95 to mem
mulx r14, r15, r12; x219, x218<- x192 * 0xffffffffffffffff
seto r12b; spill OF x195 to reg (r12)
mov [ rsp + 0xf0 ], r14; spilling x219 to mem
mov r14, -0x2 ; moving imm to reg
inc r14; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r15, [ rsp + 0xa8 ]
setc r14b; spill CF x153 to reg (r14)
clc;
mov byte [ rsp + 0xf8 ], r12b; spilling byte x195 to mem
mov r12, -0x1 ; moving imm to reg
movzx rdi, dil
adcx rdi, r12; loading flag
adcx rbx, r15
xchg rdx, r13; x3, swapping with x192, which is currently in rdx
mulx rdi, r15, [ rax + 0x0 ]; x265, x264<- x3 * arg2[0]
seto r12b; spill OF x223 to reg (r12)
mov [ rsp + 0x100 ], rdi; spilling x265 to mem
mov rdi, -0x2 ; moving imm to reg
inc rdi; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r15, rbx
mov rbx, 0xffffffffffffffff ; moving imm to reg
xchg rdx, rbx; 0xffffffffffffffff, swapping with x3, which is currently in rdx
mov byte [ rsp + 0x108 ], r12b; spilling byte x223 to mem
mulx rdi, r12, r15; x308, x307<- x279 * 0xffffffffffffffff
seto dl; spill OF x280 to reg (rdx)
mov [ rsp + 0x110 ], rdi; spilling x308 to mem
mov rdi, -0x2 ; moving imm to reg
inc rdi; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r12, r15
xchg rdx, r11; x7, swapping with x280, which is currently in rdx
mulx r12, rdi, [ rax + 0x20 ]; x13, x12<- x7 * arg2[4]
mov [ rsp + 0x118 ], r12; spilling x13 to mem
mov r12, 0x7bc65c783158aea3 ; moving imm to reg
xchg rdx, rbp; x20, swapping with x7, which is currently in rdx
mov byte [ rsp + 0x120 ], r11b; spilling byte x280 to mem
mov byte [ rsp + 0x128 ], r14b; spilling byte x153 to mem
mulx r11, r14, r12; x40, x39<- x20 * 0x7bc65c783158aea3
seto r12b; spill OF x323 to reg (r12)
mov [ rsp + 0x130 ], r11; spilling x40 to mem
mov r11, -0x1 ; moving imm to reg
inc r11; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r11, -0x1 ; moving imm to reg
movzx r9, r9b
adox r9, r11; loading flag
adox r14, [ rsp + 0xb8 ]
setc r9b; spill CF x238 to reg (r9)
clc;
movzx r8, r8b
adcx r8, r11; loading flag
adcx rdi, [ rsp + 0xd0 ]
seto r8b; spill OF x56 to reg (r8)
inc r11; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r11, -0x1 ; moving imm to reg
movzx rcx, cl
adox rcx, r11; loading flag
adox rdi, r14
xchg rdx, r10; x1, swapping with x20, which is currently in rdx
mulx rcx, r14, [ rax + 0x18 ]; x85, x84<- x1 * arg2[3]
setc r11b; spill CF x29 to reg (r11)
mov [ rsp + 0x138 ], rcx; spilling x85 to mem
movzx rcx, byte [ rsp + 0xe8 ]; load byte memx95 to register64
clc;
mov byte [ rsp + 0x140 ], r8b; spilling byte x56 to mem
mov r8, -0x1 ; moving imm to reg
adcx rcx, r8; loading flag
adcx r14, [ rsp + 0xd8 ]
seto cl; spill OF x71 to reg (rcx)
movzx r8, byte [ rsp + 0xe0 ]; load byte memx110 to register64
mov byte [ rsp + 0x148 ], r11b; spilling byte x29 to mem
mov r11, -0x1 ; moving imm to reg
inc r11; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r11, -0x1 ; moving imm to reg
adox r8, r11; loading flag
adox rdi, r14
setc r8b; spill CF x97 to reg (r8)
movzx r14, byte [ rsp + 0x128 ]; load byte memx153 to register64
clc;
adcx r14, r11; loading flag
adcx rdi, [ rsp + 0x28 ]
mov r14, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r14; 0xffffffffffffffff, swapping with x1, which is currently in rdx
mov byte [ rsp + 0x150 ], r8b; spilling byte x97 to mem
mulx r11, r8, r13; x217, x216<- x192 * 0xffffffffffffffff
setc dl; spill CF x155 to reg (rdx)
mov [ rsp + 0x158 ], r11; spilling x217 to mem
movzx r11, byte [ rsp + 0xf8 ]; load byte memx195 to register64
clc;
mov byte [ rsp + 0x160 ], cl; spilling byte x71 to mem
mov rcx, -0x1 ; moving imm to reg
adcx r11, rcx; loading flag
adcx rdi, [ rsp + 0x70 ]
seto r11b; spill OF x112 to reg (r11)
movzx rcx, byte [ rsp + 0x108 ]; load byte memx223 to register64
mov byte [ rsp + 0x168 ], dl; spilling byte x155 to mem
mov rdx, 0x0 ; moving imm to reg
dec rdx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox rcx, rdx; loading flag
adox r8, [ rsp + 0xf0 ]
mov rdx, [ rax + 0x8 ]; arg2[1] to rdx
mov byte [ rsp + 0x170 ], r11b; spilling byte x112 to mem
mulx rcx, r11, rbx; x263, x262<- x3 * arg2[1]
mov [ rsp + 0x178 ], rcx; spilling x263 to mem
setc cl; spill CF x197 to reg (rcx)
clc;
mov byte [ rsp + 0x180 ], r12b; spilling byte x323 to mem
mov r12, -0x1 ; moving imm to reg
movzx r9, r9b
adcx r9, r12; loading flag
adcx rdi, r8
setc r9b; spill CF x240 to reg (r9)
clc;
adcx r11, [ rsp + 0x100 ]
setc r8b; spill CF x267 to reg (r8)
movzx r12, byte [ rsp + 0x120 ]; load byte memx280 to register64
clc;
mov byte [ rsp + 0x188 ], r9b; spilling byte x240 to mem
mov r9, -0x1 ; moving imm to reg
adcx r12, r9; loading flag
adcx rdi, r11
mov r12, 0xffffffffffffffff ; moving imm to reg
mov rdx, r12; 0xffffffffffffffff to rdx
mulx r12, r11, r15; x306, x305<- x279 * 0xffffffffffffffff
setc r9b; spill CF x282 to reg (r9)
clc;
adcx r11, [ rsp + 0x110 ]
setc dl; spill CF x310 to reg (rdx)
mov [ rsp + 0x190 ], r12; spilling x306 to mem
movzx r12, byte [ rsp + 0x180 ]; load byte memx323 to register64
clc;
mov byte [ rsp + 0x198 ], r9b; spilling byte x282 to mem
mov r9, -0x1 ; moving imm to reg
adcx r12, r9; loading flag
adcx rdi, r11
mov r12b, dl; preserving value of x310 into a new reg
mov rdx, [ rax + 0x28 ]; saving arg2[5] in rdx.
mulx r11, r9, rbp; x11, x10<- x7 * arg2[5]
mov [ rsp + 0x1a0 ], rdi; spilling x324 to mem
mov rdi, 0x6cfc5fd681c52056 ; moving imm to reg
mov rdx, rdi; 0x6cfc5fd681c52056 to rdx
mov [ rsp + 0x1a8 ], r11; spilling x11 to mem
mov byte [ rsp + 0x1b0 ], r12b; spilling byte x310 to mem
mulx r11, r12, r10; x38, x37<- x20 * 0x6cfc5fd681c52056
setc dl; spill CF x325 to reg (rdx)
mov [ rsp + 0x1b8 ], r11; spilling x38 to mem
movzx r11, byte [ rsp + 0x148 ]; load byte memx29 to register64
clc;
mov byte [ rsp + 0x1c0 ], r8b; spilling byte x267 to mem
mov r8, -0x1 ; moving imm to reg
adcx r11, r8; loading flag
adcx r9, [ rsp + 0x118 ]
seto r11b; spill OF x225 to reg (r11)
movzx r8, byte [ rsp + 0x140 ]; load byte memx56 to register64
mov byte [ rsp + 0x1c8 ], dl; spilling byte x325 to mem
mov rdx, -0x1 ; moving imm to reg
inc rdx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rdx, -0x1 ; moving imm to reg
adox r8, rdx; loading flag
adox r12, [ rsp + 0x130 ]
seto r8b; spill OF x58 to reg (r8)
movzx rdx, byte [ rsp + 0x160 ]; load byte memx71 to register64
mov byte [ rsp + 0x1d0 ], r11b; spilling byte x225 to mem
mov r11, -0x1 ; moving imm to reg
inc r11; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r11, -0x1 ; moving imm to reg
adox rdx, r11; loading flag
adox r9, r12
mov rdx, r14; x1 to rdx
mulx r14, r12, [ rax + 0x20 ]; x83, x82<- x1 * arg2[4]
seto r11b; spill OF x73 to reg (r11)
mov [ rsp + 0x1d8 ], r14; spilling x83 to mem
movzx r14, byte [ rsp + 0x150 ]; load byte memx97 to register64
mov byte [ rsp + 0x1e0 ], r8b; spilling byte x58 to mem
mov r8, -0x1 ; moving imm to reg
inc r8; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r8, -0x1 ; moving imm to reg
adox r14, r8; loading flag
adox r12, [ rsp + 0x138 ]
setc r14b; spill CF x31 to reg (r14)
movzx r8, byte [ rsp + 0x170 ]; load byte memx112 to register64
clc;
mov byte [ rsp + 0x1e8 ], r11b; spilling byte x73 to mem
mov r11, -0x1 ; moving imm to reg
adcx r8, r11; loading flag
adcx r9, r12
setc r8b; spill CF x114 to reg (r8)
movzx r12, byte [ rsp + 0x168 ]; load byte memx155 to register64
clc;
adcx r12, r11; loading flag
adcx r9, [ rsp + 0x30 ]
seto r12b; spill OF x99 to reg (r12)
inc r11; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r11, -0x1 ; moving imm to reg
movzx rcx, cl
adox rcx, r11; loading flag
adox r9, [ rsp + 0x78 ]
mov rcx, 0xfdc1767ae2ffffff ; moving imm to reg
xchg rdx, rcx; 0xfdc1767ae2ffffff, swapping with x1, which is currently in rdx
mov byte [ rsp + 0x1f0 ], r8b; spilling byte x114 to mem
mulx r11, r8, r13; x215, x214<- x192 * 0xfdc1767ae2ffffff
seto dl; spill OF x199 to reg (rdx)
mov [ rsp + 0x1f8 ], r11; spilling x215 to mem
movzx r11, byte [ rsp + 0x1d0 ]; load byte memx225 to register64
mov byte [ rsp + 0x200 ], r12b; spilling byte x99 to mem
mov r12, 0x0 ; moving imm to reg
dec r12; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox r11, r12; loading flag
adox r8, [ rsp + 0x158 ]
xchg rdx, rbx; x3, swapping with x199, which is currently in rdx
mulx r11, r12, [ rax + 0x10 ]; x261, x260<- x3 * arg2[2]
mov [ rsp + 0x208 ], r11; spilling x261 to mem
seto r11b; spill OF x227 to reg (r11)
mov byte [ rsp + 0x210 ], bl; spilling byte x199 to mem
movzx rbx, byte [ rsp + 0x188 ]; load byte memx240 to register64
mov byte [ rsp + 0x218 ], r14b; spilling byte x31 to mem
mov r14, -0x1 ; moving imm to reg
inc r14; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r14, -0x1 ; moving imm to reg
adox rbx, r14; loading flag
adox r9, r8
setc bl; spill CF x157 to reg (rbx)
movzx r8, byte [ rsp + 0x1c0 ]; load byte memx267 to register64
clc;
adcx r8, r14; loading flag
adcx r12, [ rsp + 0x178 ]
mov r8, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r15; x279, swapping with x3, which is currently in rdx
mov byte [ rsp + 0x220 ], r11b; spilling byte x227 to mem
mulx r14, r11, r8; x304, x303<- x279 * 0xffffffffffffffff
setc r8b; spill CF x269 to reg (r8)
mov [ rsp + 0x228 ], r14; spilling x304 to mem
movzx r14, byte [ rsp + 0x198 ]; load byte memx282 to register64
clc;
mov byte [ rsp + 0x230 ], bl; spilling byte x157 to mem
mov rbx, -0x1 ; moving imm to reg
adcx r14, rbx; loading flag
adcx r9, r12
seto r14b; spill OF x242 to reg (r14)
movzx r12, byte [ rsp + 0x1b0 ]; load byte memx310 to register64
inc rbx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rbx, -0x1 ; moving imm to reg
adox r12, rbx; loading flag
adox r11, [ rsp + 0x190 ]
setc r12b; spill CF x284 to reg (r12)
movzx rbx, byte [ rsp + 0x1c8 ]; load byte memx325 to register64
clc;
mov byte [ rsp + 0x238 ], r8b; spilling byte x269 to mem
mov r8, -0x1 ; moving imm to reg
adcx rbx, r8; loading flag
adcx r9, r11
xchg rdx, rbp; x7, swapping with x279, which is currently in rdx
mulx rdx, rbx, [ rax + 0x30 ]; x9, x8<- x7 * arg2[6]
seto r11b; spill OF x312 to reg (r11)
movzx r8, byte [ rsp + 0x218 ]; load byte memx31 to register64
mov [ rsp + 0x240 ], r9; spilling x326 to mem
mov r9, 0x0 ; moving imm to reg
dec r9; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox r8, r9; loading flag
adox rbx, [ rsp + 0x1a8 ]
mov r8, 0x2341f27177344 ; moving imm to reg
xchg rdx, r8; 0x2341f27177344, swapping with x9, which is currently in rdx
mulx r10, r9, r10; x36, x35<- x20 * 0x2341f27177344
seto dl; spill OF x33 to reg (rdx)
mov [ rsp + 0x248 ], r10; spilling x36 to mem
movzx r10, byte [ rsp + 0x1e0 ]; load byte memx58 to register64
mov [ rsp + 0x250 ], r8; spilling x9 to mem
mov r8, -0x1 ; moving imm to reg
inc r8; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r8, -0x1 ; moving imm to reg
adox r10, r8; loading flag
adox r9, [ rsp + 0x1b8 ]
mov r10b, dl; preserving value of x33 into a new reg
mov rdx, [ rax + 0x28 ]; saving arg2[5] in rdx.
mov byte [ rsp + 0x258 ], r11b; spilling byte x312 to mem
mulx r8, r11, rcx; x81, x80<- x1 * arg2[5]
mov [ rsp + 0x260 ], r8; spilling x81 to mem
seto r8b; spill OF x60 to reg (r8)
mov byte [ rsp + 0x268 ], r10b; spilling byte x33 to mem
movzx r10, byte [ rsp + 0x1e8 ]; load byte memx73 to register64
mov byte [ rsp + 0x270 ], r12b; spilling byte x284 to mem
mov r12, -0x1 ; moving imm to reg
inc r12; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r12, -0x1 ; moving imm to reg
adox r10, r12; loading flag
adox rbx, r9
setc r10b; spill CF x327 to reg (r10)
movzx r9, byte [ rsp + 0x200 ]; load byte memx99 to register64
clc;
adcx r9, r12; loading flag
adcx r11, [ rsp + 0x1d8 ]
setc r9b; spill CF x101 to reg (r9)
movzx r12, byte [ rsp + 0x1f0 ]; load byte memx114 to register64
clc;
mov byte [ rsp + 0x278 ], r8b; spilling byte x60 to mem
mov r8, -0x1 ; moving imm to reg
adcx r12, r8; loading flag
adcx rbx, r11
mov r12, 0x7bc65c783158aea3 ; moving imm to reg
mov rdx, r12; 0x7bc65c783158aea3 to rdx
mulx r12, r11, r13; x213, x212<- x192 * 0x7bc65c783158aea3
seto r8b; spill OF x75 to reg (r8)
movzx rdx, byte [ rsp + 0x230 ]; load byte memx157 to register64
mov [ rsp + 0x280 ], r12; spilling x213 to mem
mov r12, 0x0 ; moving imm to reg
dec r12; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox rdx, r12; loading flag
adox rbx, [ rsp + 0x38 ]
setc dl; spill CF x116 to reg (rdx)
movzx r12, byte [ rsp + 0x210 ]; load byte memx199 to register64
clc;
mov byte [ rsp + 0x288 ], r8b; spilling byte x75 to mem
mov r8, -0x1 ; moving imm to reg
adcx r12, r8; loading flag
adcx rbx, [ rsp + 0x98 ]
seto r12b; spill OF x159 to reg (r12)
movzx r8, byte [ rsp + 0x220 ]; load byte memx227 to register64
mov byte [ rsp + 0x290 ], dl; spilling byte x116 to mem
mov rdx, -0x1 ; moving imm to reg
inc rdx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rdx, -0x1 ; moving imm to reg
adox r8, rdx; loading flag
adox r11, [ rsp + 0x1f8 ]
seto r8b; spill OF x229 to reg (r8)
inc rdx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rdx, -0x1 ; moving imm to reg
movzx r14, r14b
adox r14, rdx; loading flag
adox rbx, r11
mov rdx, r15; x3 to rdx
mulx r15, r14, [ rax + 0x18 ]; x259, x258<- x3 * arg2[3]
seto r11b; spill OF x244 to reg (r11)
mov [ rsp + 0x298 ], r15; spilling x259 to mem
movzx r15, byte [ rsp + 0x238 ]; load byte memx269 to register64
mov byte [ rsp + 0x2a0 ], r8b; spilling byte x229 to mem
mov r8, 0x0 ; moving imm to reg
dec r8; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox r15, r8; loading flag
adox r14, [ rsp + 0x208 ]
setc r15b; spill CF x201 to reg (r15)
movzx r8, byte [ rsp + 0x270 ]; load byte memx284 to register64
clc;
mov byte [ rsp + 0x2a8 ], r11b; spilling byte x244 to mem
mov r11, -0x1 ; moving imm to reg
adcx r8, r11; loading flag
adcx rbx, r14
mov r8, 0xfdc1767ae2ffffff ; moving imm to reg
xchg rdx, r8; 0xfdc1767ae2ffffff, swapping with x3, which is currently in rdx
mulx r14, r11, rbp; x302, x301<- x279 * 0xfdc1767ae2ffffff
setc dl; spill CF x286 to reg (rdx)
mov [ rsp + 0x2b0 ], r14; spilling x302 to mem
movzx r14, byte [ rsp + 0x258 ]; load byte memx312 to register64
clc;
mov byte [ rsp + 0x2b8 ], r15b; spilling byte x201 to mem
mov r15, -0x1 ; moving imm to reg
adcx r14, r15; loading flag
adcx r11, [ rsp + 0x228 ]
movzx r14, byte [ rsp + 0x268 ]; x34, copying x33 here, cause x33 is needed in a reg for other than x34, namely all: , x34, size: 1
mov r15, [ rsp + 0x250 ]; load m64 x9 to register64
lea r14, [ r14 + r15 ]; r8/64 + m8
seto r15b; spill OF x271 to reg (r15)
mov byte [ rsp + 0x2c0 ], dl; spilling byte x286 to mem
mov rdx, 0x0 ; moving imm to reg
dec rdx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx r10, r10b
adox r10, rdx; loading flag
adox rbx, r11
movzx r10, byte [ rsp + 0x278 ]; x61, copying x60 here, cause x60 is needed in a reg for other than x61, namely all: , x61, size: 1
mov r11, [ rsp + 0x248 ]; load m64 x36 to register64
lea r10, [ r10 + r11 ]; r8/64 + m8
mov rdx, [ rax + 0x30 ]; arg2[6] to rdx
mulx rcx, r11, rcx; x79, x78<- x1 * arg2[6]
mov [ rsp + 0x2c8 ], rbx; spilling x328 to mem
seto bl; spill OF x329 to reg (rbx)
mov [ rsp + 0x2d0 ], rcx; spilling x79 to mem
mov rcx, 0x0 ; moving imm to reg
dec rcx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx r9, r9b
adox r9, rcx; loading flag
adox r11, [ rsp + 0x260 ]
seto r9b; spill OF x103 to reg (r9)
movzx rcx, byte [ rsp + 0x288 ]; load byte memx75 to register64
mov byte [ rsp + 0x2d8 ], bl; spilling byte x329 to mem
mov rbx, 0x0 ; moving imm to reg
dec rbx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox rcx, rbx; loading flag
adox r14, r10
seto cl; spill OF x77 to reg (rcx)
movzx r10, byte [ rsp + 0x290 ]; load byte memx116 to register64
inc rbx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rbx, -0x1 ; moving imm to reg
adox r10, rbx; loading flag
adox r14, r11
setc r10b; spill CF x314 to reg (r10)
clc;
movzx r12, r12b
adcx r12, rbx; loading flag
adcx r14, [ rsp + 0x48 ]
mov r12, 0x6cfc5fd681c52056 ; moving imm to reg
mov rdx, r12; 0x6cfc5fd681c52056 to rdx
mulx r12, r11, r13; x211, x210<- x192 * 0x6cfc5fd681c52056
setc bl; spill CF x161 to reg (rbx)
movzx rdx, byte [ rsp + 0x2b8 ]; load byte memx201 to register64
clc;
mov [ rsp + 0x2e0 ], r12; spilling x211 to mem
mov r12, -0x1 ; moving imm to reg
adcx rdx, r12; loading flag
adcx r14, [ rsp + 0x90 ]
setc dl; spill CF x203 to reg (rdx)
movzx r12, byte [ rsp + 0x2a0 ]; load byte memx229 to register64
clc;
mov byte [ rsp + 0x2e8 ], bl; spilling byte x161 to mem
mov rbx, -0x1 ; moving imm to reg
adcx r12, rbx; loading flag
adcx r11, [ rsp + 0x280 ]
setc r12b; spill CF x231 to reg (r12)
movzx rbx, byte [ rsp + 0x2a8 ]; load byte memx244 to register64
clc;
mov byte [ rsp + 0x2f0 ], dl; spilling byte x203 to mem
mov rdx, -0x1 ; moving imm to reg
adcx rbx, rdx; loading flag
adcx r14, r11
mov rdx, [ rax + 0x20 ]; arg2[4] to rdx
mulx rbx, r11, r8; x257, x256<- x3 * arg2[4]
mov [ rsp + 0x2f8 ], rbx; spilling x257 to mem
mov rbx, 0x7bc65c783158aea3 ; moving imm to reg
mov rdx, rbp; x279 to rdx
mov byte [ rsp + 0x300 ], r12b; spilling byte x231 to mem
mulx rbp, r12, rbx; x300, x299<- x279 * 0x7bc65c783158aea3
seto bl; spill OF x118 to reg (rbx)
mov [ rsp + 0x308 ], rbp; spilling x300 to mem
mov rbp, 0x0 ; moving imm to reg
dec rbp; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx r15, r15b
adox r15, rbp; loading flag
adox r11, [ rsp + 0x298 ]
setc r15b; spill CF x246 to reg (r15)
clc;
movzx r10, r10b
adcx r10, rbp; loading flag
adcx r12, [ rsp + 0x2b0 ]
setc r10b; spill CF x316 to reg (r10)
movzx rbp, byte [ rsp + 0x2c0 ]; load byte memx286 to register64
clc;
mov byte [ rsp + 0x310 ], r15b; spilling byte x246 to mem
mov r15, -0x1 ; moving imm to reg
adcx rbp, r15; loading flag
adcx r14, r11
movzx rbp, r9b; x104, copying x103 here, cause x103 is needed in a reg for other than x104, namely all: , x104, size: 1
mov r11, [ rsp + 0x2d0 ]; load m64 x79 to register64
lea rbp, [ rbp + r11 ]; r8/64 + m8
seto r11b; spill OF x273 to reg (r11)
movzx r9, byte [ rsp + 0x2d8 ]; load byte memx329 to register64
inc r15; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r15, -0x1 ; moving imm to reg
adox r9, r15; loading flag
adox r14, r12
seto r9b; spill OF x331 to reg (r9)
inc r15; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r12, -0x1 ; moving imm to reg
movzx rcx, cl
movzx rbx, bl
adox rbx, r12; loading flag
adox rbp, rcx
seto cl; spill OF x120 to reg (rcx)
movzx rbx, byte [ rsp + 0x2e8 ]; load byte memx161 to register64
inc r12; OF<-0x0, preserve CF (debug: state 1(-0x1) (thanks Paul))
mov r15, -0x1 ; moving imm to reg
adox rbx, r15; loading flag
adox rbp, [ rsp + 0x40 ]
seto bl; spill OF x163 to reg (rbx)
movzx r12, byte [ rsp + 0x2f0 ]; load byte memx203 to register64
inc r15; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r15, -0x1 ; moving imm to reg
adox r12, r15; loading flag
adox rbp, [ rsp + 0x88 ]
mov r12, 0x2341f27177344 ; moving imm to reg
xchg rdx, r12; 0x2341f27177344, swapping with x279, which is currently in rdx
mulx r13, r15, r13; x209, x208<- x192 * 0x2341f27177344
seto dl; spill OF x205 to reg (rdx)
mov [ rsp + 0x318 ], r14; spilling x330 to mem
movzx r14, byte [ rsp + 0x300 ]; load byte memx231 to register64
mov [ rsp + 0x320 ], r13; spilling x209 to mem
mov r13, -0x1 ; moving imm to reg
inc r13; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r13, -0x1 ; moving imm to reg
adox r14, r13; loading flag
adox r15, [ rsp + 0x2e0 ]
seto r14b; spill OF x233 to reg (r14)
movzx r13, byte [ rsp + 0x310 ]; load byte memx246 to register64
mov byte [ rsp + 0x328 ], r9b; spilling byte x331 to mem
mov r9, -0x1 ; moving imm to reg
inc r9; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r9, -0x1 ; moving imm to reg
adox r13, r9; loading flag
adox rbp, r15
mov r13b, dl; preserving value of x205 into a new reg
mov rdx, [ rax + 0x28 ]; saving arg2[5] in rdx.
mulx r15, r9, r8; x255, x254<- x3 * arg2[5]
mov [ rsp + 0x330 ], r15; spilling x255 to mem
setc r15b; spill CF x288 to reg (r15)
clc;
mov byte [ rsp + 0x338 ], r14b; spilling byte x233 to mem
mov r14, -0x1 ; moving imm to reg
movzx r11, r11b
adcx r11, r14; loading flag
adcx r9, [ rsp + 0x2f8 ]
seto r11b; spill OF x248 to reg (r11)
inc r14; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r14, -0x1 ; moving imm to reg
movzx r15, r15b
adox r15, r14; loading flag
adox rbp, r9
mov r15, 0x6cfc5fd681c52056 ; moving imm to reg
mov rdx, r15; 0x6cfc5fd681c52056 to rdx
mulx r15, r9, r12; x298, x297<- x279 * 0x6cfc5fd681c52056
movzx r14, bl; x164, copying x163 here, cause x163 is needed in a reg for other than x164, namely all: , x164, size: 1
movzx rcx, cl
lea r14, [ r14 + rcx ]
seto cl; spill OF x290 to reg (rcx)
mov rbx, -0x1 ; moving imm to reg
inc rbx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rbx, -0x1 ; moving imm to reg
movzx r10, r10b
adox r10, rbx; loading flag
adox r9, [ rsp + 0x308 ]
seto r10b; spill OF x318 to reg (r10)
inc rbx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rbx, -0x1 ; moving imm to reg
movzx r13, r13b
adox r13, rbx; loading flag
adox r14, [ rsp + 0x80 ]
seto r13b; spill OF x207 to reg (r13)
movzx rbx, byte [ rsp + 0x328 ]; load byte memx331 to register64
mov rdx, 0x0 ; moving imm to reg
dec rdx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox rbx, rdx; loading flag
adox rbp, r9
movzx rbx, byte [ rsp + 0x338 ]; x234, copying x233 here, cause x233 is needed in a reg for other than x234, namely all: , x234, size: 1
mov r9, [ rsp + 0x320 ]; load m64 x209 to register64
lea rbx, [ rbx + r9 ]; r8/64 + m8
mov rdx, r8; x3 to rdx
mulx rdx, r8, [ rax + 0x30 ]; x253, x252<- x3 * arg2[6]
setc r9b; spill CF x275 to reg (r9)
clc;
mov [ rsp + 0x340 ], rbp; spilling x332 to mem
mov rbp, -0x1 ; moving imm to reg
movzx r11, r11b
adcx r11, rbp; loading flag
adcx r14, rbx
setc r11b; spill CF x250 to reg (r11)
clc;
movzx r9, r9b
adcx r9, rbp; loading flag
adcx r8, [ rsp + 0x330 ]
seto r9b; spill OF x333 to reg (r9)
inc rbp; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rbx, -0x1 ; moving imm to reg
movzx rcx, cl
adox rcx, rbx; loading flag
adox r14, r8
mov rcx, 0x2341f27177344 ; moving imm to reg
xchg rdx, r12; x279, swapping with x253, which is currently in rdx
mulx rdx, r8, rcx; x296, x295<- x279 * 0x2341f27177344
setc bpl; spill CF x277 to reg (rbp)
clc;
movzx r10, r10b
adcx r10, rbx; loading flag
adcx r15, r8
setc r10b; spill CF x320 to reg (r10)
clc;
movzx r9, r9b
adcx r9, rbx; loading flag
adcx r14, r15
movzx r9, bpl; x278, copying x277 here, cause x277 is needed in a reg for other than x278, namely all: , x278, size: 1
lea r9, [ r9 + r12 ]
movzx r12, r11b; x251, copying x250 here, cause x250 is needed in a reg for other than x251, namely all: , x251, size: 1
movzx r13, r13b
lea r12, [ r12 + r13 ]
adox r9, r12
movzx r13, r10b; x321, copying x320 here, cause x320 is needed in a reg for other than x321, namely all: , x321, size: 1
lea r13, [ r13 + rdx ]
adcx r13, r9
seto r11b; spill OF x338 to reg (r11)
adc r11b, 0x0
movzx r11, r11b
mov rbp, [ rsi + 0x20 ]; load m64 x4 to register64
mov rdx, rbp; x4 to rdx
mulx rbp, r8, [ rax + 0x0 ]; x352, x351<- x4 * arg2[0]
adox r8, [ rsp + 0x1a0 ]
mov r15, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r8; x366, swapping with x4, which is currently in rdx
mulx r10, r12, r15; x395, x394<- x366 * 0xffffffffffffffff
adcx r12, rdx
mov r12, rdx; preserving value of x366 into a new reg
mov rdx, [ rax + 0x8 ]; saving arg2[1] in rdx.
mulx r9, rbx, r8; x350, x349<- x4 * arg2[1]
setc cl; spill CF x410 to reg (rcx)
clc;
adcx rbx, rbp
mov rdx, r12; x366 to rdx
mulx r12, rbp, r15; x393, x392<- x366 * 0xffffffffffffffff
xchg rdx, r8; x4, swapping with x366, which is currently in rdx
mov byte [ rsp + 0x348 ], r11b; spilling byte x338 to mem
mulx r15, r11, [ rax + 0x10 ]; x348, x347<- x4 * arg2[2]
mov [ rsp + 0x350 ], r13; spilling x336 to mem
mov r13, [ rsp + 0x240 ]; x368, copying x326 here, cause x326 is needed in a reg for other than x368, namely all: , x368--x369, size: 1
adox r13, rbx
setc bl; spill CF x354 to reg (rbx)
clc;
adcx rbp, r10
seto r10b; spill OF x369 to reg (r10)
mov [ rsp + 0x358 ], r14; spilling x334 to mem
mov r14, 0x0 ; moving imm to reg
dec r14; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx rcx, cl
adox rcx, r14; loading flag
adox r13, rbp
setc cl; spill CF x397 to reg (rcx)
clc;
movzx rbx, bl
adcx rbx, r14; loading flag
adcx r9, r11
setc bl; spill CF x356 to reg (rbx)
clc;
movzx r10, r10b
adcx r10, r14; loading flag
adcx r9, [ rsp + 0x2c8 ]
mov r11, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r8; x366, swapping with x4, which is currently in rdx
mulx r10, rbp, r11; x391, x390<- x366 * 0xffffffffffffffff
seto r14b; spill OF x412 to reg (r14)
mov r11, -0x1 ; moving imm to reg
inc r11; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r11, -0x1 ; moving imm to reg
movzx rcx, cl
adox rcx, r11; loading flag
adox r12, rbp
seto cl; spill OF x399 to reg (rcx)
inc r11; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rbp, -0x1 ; moving imm to reg
movzx r14, r14b
adox r14, rbp; loading flag
adox r9, r12
mov r14, rdx; preserving value of x366 into a new reg
mov rdx, [ rax + 0x18 ]; saving arg2[3] in rdx.
mulx r12, r11, r8; x346, x345<- x4 * arg2[3]
seto bpl; spill OF x414 to reg (rbp)
mov [ rsp + 0x360 ], r9; spilling x413 to mem
mov r9, -0x1 ; moving imm to reg
inc r9; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r9, -0x1 ; moving imm to reg
movzx rbx, bl
adox rbx, r9; loading flag
adox r15, r11
mov rbx, 0xfdc1767ae2ffffff ; moving imm to reg
mov rdx, r14; x366 to rdx
mulx r14, r11, rbx; x389, x388<- x366 * 0xfdc1767ae2ffffff
mov r9, [ rsp + 0x318 ]; x372, copying x330 here, cause x330 is needed in a reg for other than x372, namely all: , x372--x373, size: 1
adcx r9, r15
seto r15b; spill OF x358 to reg (r15)
mov rbx, -0x1 ; moving imm to reg
inc rbx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rbx, -0x1 ; moving imm to reg
movzx rcx, cl
adox rcx, rbx; loading flag
adox r10, r11
setc cl; spill CF x373 to reg (rcx)
clc;
movzx rbp, bpl
adcx rbp, rbx; loading flag
adcx r9, r10
mov rbp, rdx; preserving value of x366 into a new reg
mov rdx, [ rax + 0x20 ]; saving arg2[4] in rdx.
mulx r11, r10, r8; x344, x343<- x4 * arg2[4]
seto bl; spill OF x401 to reg (rbx)
mov [ rsp + 0x368 ], r9; spilling x415 to mem
mov r9, -0x1 ; moving imm to reg
inc r9; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r9, -0x1 ; moving imm to reg
movzx r15, r15b
adox r15, r9; loading flag
adox r12, r10
setc r15b; spill CF x416 to reg (r15)
clc;
movzx rcx, cl
adcx rcx, r9; loading flag
adcx r12, [ rsp + 0x340 ]
mov rcx, 0x7bc65c783158aea3 ; moving imm to reg
mov rdx, rcx; 0x7bc65c783158aea3 to rdx
mulx rcx, r10, rbp; x387, x386<- x366 * 0x7bc65c783158aea3
setc r9b; spill CF x375 to reg (r9)
clc;
mov rdx, -0x1 ; moving imm to reg
movzx rbx, bl
adcx rbx, rdx; loading flag
adcx r14, r10
setc bl; spill CF x403 to reg (rbx)
clc;
movzx r15, r15b
adcx r15, rdx; loading flag
adcx r12, r14
mov rdx, r8; x4 to rdx
mulx r8, r15, [ rax + 0x28 ]; x342, x341<- x4 * arg2[5]
mov r10, 0x6cfc5fd681c52056 ; moving imm to reg
xchg rdx, r10; 0x6cfc5fd681c52056, swapping with x4, which is currently in rdx
mov [ rsp + 0x370 ], r12; spilling x417 to mem
mulx r14, r12, rbp; x385, x384<- x366 * 0x6cfc5fd681c52056
adox r15, r11
setc r11b; spill CF x418 to reg (r11)
clc;
mov rdx, -0x1 ; moving imm to reg
movzx r9, r9b
adcx r9, rdx; loading flag
adcx r15, [ rsp + 0x358 ]
seto r9b; spill OF x362 to reg (r9)
inc rdx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rdx, -0x1 ; moving imm to reg
movzx rbx, bl
adox rbx, rdx; loading flag
adox rcx, r12
seto bl; spill OF x405 to reg (rbx)
inc rdx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r12, -0x1 ; moving imm to reg
movzx r11, r11b
adox r11, r12; loading flag
adox r15, rcx
mov r11, rdx; preserving value of 0x0 into a new reg
mov rdx, [ rax + 0x30 ]; saving arg2[6] in rdx.
mulx r10, rcx, r10; x340, x339<- x4 * arg2[6]
seto r11b; spill OF x420 to reg (r11)
inc r12; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r12, -0x1 ; moving imm to reg
movzx r9, r9b
adox r9, r12; loading flag
adox r8, rcx
mov r9, 0x2341f27177344 ; moving imm to reg
mov rdx, r9; 0x2341f27177344 to rdx
mulx rbp, r9, rbp; x383, x382<- x366 * 0x2341f27177344
mov rcx, [ rsp + 0x350 ]; x378, copying x336 here, cause x336 is needed in a reg for other than x378, namely all: , x378--x379, size: 1
adcx rcx, r8
mov r8, 0x0 ; moving imm to reg
adox r10, r8
dec r8; OF<-0x0, preserve CF (debug: state 1(0x0) (thanks Paul))
movzx rbx, bl
adox rbx, r8; loading flag
adox r14, r9
mov r12, 0x0 ; moving imm to reg
adox rbp, r12
inc r8; OF<-0x0, preserve CF (debug: state 1(-0x1) (thanks Paul))
mov r12, -0x1 ; moving imm to reg
movzx r11, r11b
adox r11, r12; loading flag
adox rcx, r14
movzx rbx, byte [ rsp + 0x348 ]; x380, copying x338 here, cause x338 is needed in a reg for other than x380, namely all: , x380--x381, size: 1
adcx rbx, r10
adox rbp, rbx
mov r11, [ rsi + 0x28 ]; load m64 x5 to register64
seto r9b; spill OF x425 to reg (r9)
adc r9b, 0x0
movzx r9, r9b
mov r10, rdx; preserving value of 0x2341f27177344 into a new reg
mov rdx, [ rax + 0x0 ]; saving arg2[0] in rdx.
mulx r14, rbx, r11; x439, x438<- x5 * arg2[0]
mov rdx, [ rax + 0x18 ]; arg2[3] to rdx
mulx r8, r12, r11; x433, x432<- x5 * arg2[3]
mov rdx, [ rax + 0x8 ]; arg2[1] to rdx
mov byte [ rsp + 0x378 ], r9b; spilling byte x425 to mem
mulx r10, r9, r11; x437, x436<- x5 * arg2[1]
adox r9, r14
mov rdx, [ rax + 0x10 ]; arg2[2] to rdx
mov [ rsp + 0x380 ], rbp; spilling x423 to mem
mulx r14, rbp, r11; x435, x434<- x5 * arg2[2]
adox rbp, r10
adox r12, r14
mov rdx, r11; x5 to rdx
mulx r11, r10, [ rax + 0x28 ]; x429, x428<- x5 * arg2[5]
mov [ rsp + 0x388 ], rcx; spilling x421 to mem
mulx r14, rcx, [ rax + 0x20 ]; x431, x430<- x5 * arg2[4]
adox rcx, r8
adox r10, r14
mulx rdx, r8, [ rax + 0x30 ]; x427, x426<- x5 * arg2[6]
adcx rbx, r13
adox r8, r11
mov r13, 0x0 ; moving imm to reg
adox rdx, r13
mov r11, 0xffffffffffffffff ; moving imm to reg
xchg rdx, r11; 0xffffffffffffffff, swapping with x452, which is currently in rdx
mulx r14, r13, rbx; x482, x481<- x453 * 0xffffffffffffffff
mov rdx, -0x2 ; moving imm to reg
inc rdx; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r13, rbx
mov r13, 0xffffffffffffffff ; moving imm to reg
mov rdx, rbx; x453 to rdx
mov [ rsp + 0x390 ], r11; spilling x452 to mem
mulx rbx, r11, r13; x480, x479<- x453 * 0xffffffffffffffff
mov r13, [ rsp + 0x360 ]; x455, copying x413 here, cause x413 is needed in a reg for other than x455, namely all: , x455--x456, size: 1
adcx r13, r9
setc r9b; spill CF x456 to reg (r9)
clc;
adcx r11, r14
mov r14, 0xffffffffffffffff ; moving imm to reg
mov [ rsp + 0x398 ], r8; spilling x450 to mem
mov [ rsp + 0x3a0 ], r10; spilling x448 to mem
mulx r8, r10, r14; x478, x477<- x453 * 0xffffffffffffffff
adox r11, r13
setc r13b; spill CF x484 to reg (r13)
clc;
mov r14, -0x1 ; moving imm to reg
movzx r9, r9b
adcx r9, r14; loading flag
adcx rbp, [ rsp + 0x368 ]
seto r9b; spill OF x499 to reg (r9)
inc r14; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r14, -0x1 ; moving imm to reg
movzx r13, r13b
adox r13, r14; loading flag
adox rbx, r10
setc r13b; spill CF x458 to reg (r13)
clc;
movzx r9, r9b
adcx r9, r14; loading flag
adcx rbp, rbx
seto r10b; spill OF x486 to reg (r10)
inc r14; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r9, -0x1 ; moving imm to reg
movzx r13, r13b
adox r13, r9; loading flag
adox r12, [ rsp + 0x370 ]
mov r13, 0xfdc1767ae2ffffff ; moving imm to reg
mulx rbx, r14, r13; x476, x475<- x453 * 0xfdc1767ae2ffffff
seto r9b; spill OF x460 to reg (r9)
mov r13, 0x0 ; moving imm to reg
dec r13; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx r10, r10b
adox r10, r13; loading flag
adox r8, r14
adcx r8, r12
setc r10b; spill CF x503 to reg (r10)
clc;
movzx r9, r9b
adcx r9, r13; loading flag
adcx r15, rcx
mov rcx, 0x7bc65c783158aea3 ; moving imm to reg
mulx r12, r9, rcx; x474, x473<- x453 * 0x7bc65c783158aea3
adox r9, rbx
setc bl; spill CF x462 to reg (rbx)
clc;
movzx r10, r10b
adcx r10, r13; loading flag
adcx r15, r9
mov r14, [ rsp + 0x388 ]; load m64 x421 to register64
seto r10b; spill OF x490 to reg (r10)
inc r13; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r9, -0x1 ; moving imm to reg
movzx rbx, bl
adox rbx, r9; loading flag
adox r14, [ rsp + 0x3a0 ]
mov rbx, 0x6cfc5fd681c52056 ; moving imm to reg
mulx r13, r9, rbx; x472, x471<- x453 * 0x6cfc5fd681c52056
setc bl; spill CF x505 to reg (rbx)
clc;
mov rcx, -0x1 ; moving imm to reg
movzx r10, r10b
adcx r10, rcx; loading flag
adcx r12, r9
mov r10, 0x2341f27177344 ; moving imm to reg
mulx rdx, r9, r10; x470, x469<- x453 * 0x2341f27177344
mov rcx, [ rsp + 0x398 ]; load m64 x450 to register64
mov r10, [ rsp + 0x380 ]; x465, copying x423 here, cause x423 is needed in a reg for other than x465, namely all: , x465--x466, size: 1
adox r10, rcx
setc cl; spill CF x492 to reg (rcx)
clc;
mov [ rsp + 0x3a8 ], r15; spilling x504 to mem
mov r15, -0x1 ; moving imm to reg
movzx rbx, bl
adcx rbx, r15; loading flag
adcx r14, r12
setc bl; spill CF x507 to reg (rbx)
clc;
movzx rcx, cl
adcx rcx, r15; loading flag
adcx r13, r9
seto r12b; spill OF x466 to reg (r12)
inc r15; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rcx, -0x1 ; moving imm to reg
movzx rbx, bl
adox rbx, rcx; loading flag
adox r10, r13
movzx r9, byte [ rsp + 0x378 ]; load byte memx425 to register64
seto bl; spill OF x509 to reg (rbx)
inc rcx; OF<-0x0, preserve CF (debug: state 1(-0x1) (thanks Paul))
mov r15, -0x1 ; moving imm to reg
movzx r12, r12b
adox r12, r15; loading flag
adox r9, [ rsp + 0x390 ]
adcx rdx, rcx
clc;
movzx rbx, bl
adcx rbx, r15; loading flag
adcx r9, rdx
seto r12b; spill OF x512 to reg (r12)
adc r12b, 0x0
movzx r12, r12b
mov r13, [ rsi + 0x30 ]; load m64 x6 to register64
mov rdx, [ rax + 0x0 ]; arg2[0] to rdx
mulx rbx, rcx, r13; x526, x525<- x6 * arg2[0]
adox rcx, r11
mov r11, 0xffffffffffffffff ; moving imm to reg
mov rdx, r11; 0xffffffffffffffff to rdx
mulx r11, r15, rcx; x569, x568<- x540 * 0xffffffffffffffff
adcx r15, rcx
mov r15, rdx; preserving value of 0xffffffffffffffff into a new reg
mov rdx, [ rax + 0x8 ]; saving arg2[1] in rdx.
mov byte [ rsp + 0x3b0 ], r12b; spilling byte x512 to mem
mov [ rsp + 0x3b8 ], r9; spilling x510 to mem
mulx r12, r9, r13; x524, x523<- x6 * arg2[1]
seto r15b; spill OF x541 to reg (r15)
mov [ rsp + 0x3c0 ], r10; spilling x508 to mem
mov r10, -0x2 ; moving imm to reg
inc r10; OF<-0x0, preserve CF (debug: 6; load -2, increase it, save as -1)
adox r9, rbx
mov rbx, 0xffffffffffffffff ; moving imm to reg
mov rdx, rcx; x540 to rdx
mulx rcx, r10, rbx; x567, x566<- x540 * 0xffffffffffffffff
setc bl; spill CF x584 to reg (rbx)
clc;
mov [ rsp + 0x3c8 ], r14; spilling x506 to mem
mov r14, -0x1 ; moving imm to reg
movzx r15, r15b
adcx r15, r14; loading flag
adcx rbp, r9
seto r15b; spill OF x528 to reg (r15)
inc r14; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
adox r10, r11
seto r11b; spill OF x571 to reg (r11)
dec r14; OF<-0x0, preserve CF (debug: state 3 (y: 0, n: -1))
movzx rbx, bl
adox rbx, r14; loading flag
adox rbp, r10
setc bl; spill CF x543 to reg (rbx)
seto r9b; spill OF x586 to reg (r9)
mov r10, rbp; x600, copying x585 here, cause x585 is needed in a reg for other than x600, namely all: , x600--x601, x616, size: 2
mov r14, 0xffffffffffffffff ; moving imm to reg
sub r10, r14
mov r14, rdx; preserving value of x540 into a new reg
mov rdx, [ rax + 0x10 ]; saving arg2[2] in rdx.
mov [ rsp + 0x3d0 ], r10; spilling x600 to mem
mov byte [ rsp + 0x3d8 ], r9b; spilling byte x586 to mem
mulx r10, r9, r13; x522, x521<- x6 * arg2[2]
mov [ rsp + 0x3e0 ], r10; spilling x522 to mem
mov r10, 0x0 ; moving imm to reg
dec r10; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx r15, r15b
adox r15, r10; loading flag
adox r12, r9
seto r15b; spill OF x530 to reg (r15)
inc r10; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r9, -0x1 ; moving imm to reg
movzx rbx, bl
adox rbx, r9; loading flag
adox r8, r12
mov rbx, 0xffffffffffffffff ; moving imm to reg
mov rdx, r14; x540 to rdx
mulx r14, r12, rbx; x565, x564<- x540 * 0xffffffffffffffff
setc r10b; spill CF x601 to reg (r10)
clc;
movzx r11, r11b
adcx r11, r9; loading flag
adcx rcx, r12
seto r11b; spill OF x545 to reg (r11)
movzx r12, byte [ rsp + 0x3d8 ]; load byte memx586 to register64
inc r9; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov r9, -0x1 ; moving imm to reg
adox r12, r9; loading flag
adox r8, rcx
mov r12, rdx; preserving value of x540 into a new reg
mov rdx, [ rax + 0x18 ]; saving arg2[3] in rdx.
mulx rcx, r9, r13; x520, x519<- x6 * arg2[3]
mov [ rsp + 0x3e8 ], rcx; spilling x520 to mem
setc cl; spill CF x573 to reg (rcx)
mov byte [ rsp + 0x3f0 ], r11b; spilling byte x545 to mem
seto r11b; spill OF x588 to reg (r11)
mov [ rsp + 0x3f8 ], r14; spilling x565 to mem
movzx r14, r10b; x601, copying x601 here, cause x601 is needed in a reg for other than x601, namely all: , x602--x603, size: 1
add r14, -0x1
mov r10, r8; x602, copying x587 here, cause x587 is needed in a reg for other than x602, namely all: , x617, x602--x603, size: 2
sbb r10, rbx
mov r14, 0x0 ; moving imm to reg
dec r14; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx r15, r15b
adox r15, r14; loading flag
adox r9, [ rsp + 0x3e0 ]
mov r15, 0xfdc1767ae2ffffff ; moving imm to reg
mov rdx, r12; x540 to rdx
mulx r12, r14, r15; x563, x562<- x540 * 0xfdc1767ae2ffffff
setc r15b; spill CF x603 to reg (r15)
clc;
mov rbx, -0x1 ; moving imm to reg
movzx rcx, cl
adcx rcx, rbx; loading flag
adcx r14, [ rsp + 0x3f8 ]
seto cl; spill OF x532 to reg (rcx)
movzx rbx, byte [ rsp + 0x3f0 ]; load byte memx545 to register64
mov [ rsp + 0x400 ], r10; spilling x602 to mem
mov r10, -0x1 ; moving imm to reg
inc r10; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r10, -0x1 ; moving imm to reg
adox rbx, r10; loading flag
adox r9, [ rsp + 0x3a8 ]
setc bl; spill CF x575 to reg (rbx)
clc;
movzx r11, r11b
adcx r11, r10; loading flag
adcx r9, r14
setc r11b; spill CF x590 to reg (r11)
seto r14b; spill OF x547 to reg (r14)
movzx r10, r15b; x603, copying x603 here, cause x603 is needed in a reg for other than x603, namely all: , x604--x605, size: 1
add r10, -0x1
mov r10, r9; x604, copying x589 here, cause x589 is needed in a reg for other than x604, namely all: , x618, x604--x605, size: 2
mov r15, 0xffffffffffffffff ; moving imm to reg
sbb r10, r15
mov r15, rdx; preserving value of x540 into a new reg
mov rdx, [ rax + 0x20 ]; saving arg2[4] in rdx.
mov [ rsp + 0x408 ], r10; spilling x604 to mem
mov byte [ rsp + 0x410 ], r11b; spilling byte x590 to mem
mulx r10, r11, r13; x518, x517<- x6 * arg2[4]
mov [ rsp + 0x418 ], r10; spilling x518 to mem
mov r10, -0x1 ; moving imm to reg
inc r10; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov r10, -0x1 ; moving imm to reg
movzx rcx, cl
adox rcx, r10; loading flag
adox r11, [ rsp + 0x3e8 ]
setc cl; spill CF x605 to reg (rcx)
clc;
movzx r14, r14b
adcx r14, r10; loading flag
adcx r11, [ rsp + 0x3c8 ]
mov r14, 0x7bc65c783158aea3 ; moving imm to reg
mov rdx, r15; x540 to rdx
mulx r15, r10, r14; x561, x560<- x540 * 0x7bc65c783158aea3
setc r14b; spill CF x549 to reg (r14)
clc;
mov [ rsp + 0x420 ], r15; spilling x561 to mem
mov r15, -0x1 ; moving imm to reg
movzx rbx, bl
adcx rbx, r15; loading flag
adcx r12, r10
setc bl; spill CF x577 to reg (rbx)
movzx r10, byte [ rsp + 0x410 ]; load byte memx590 to register64
clc;
adcx r10, r15; loading flag
adcx r11, r12
xchg rdx, r13; x6, swapping with x540, which is currently in rdx
mulx r10, r12, [ rax + 0x28 ]; x516, x515<- x6 * arg2[5]
setc r15b; spill CF x592 to reg (r15)
mov [ rsp + 0x428 ], r10; spilling x516 to mem
seto r10b; spill OF x534 to reg (r10)
mov byte [ rsp + 0x430 ], bl; spilling byte x577 to mem
movzx rbx, cl; x605, copying x605 here, cause x605 is needed in a reg for other than x605, namely all: , x606--x607, size: 1
add rbx, -0x1
mov rbx, r11; x606, copying x591 here, cause x591 is needed in a reg for other than x606, namely all: , x606--x607, x619, size: 2
mov rcx, 0xfdc1767ae2ffffff ; moving imm to reg
sbb rbx, rcx
mov rcx, -0x1 ; moving imm to reg
inc rcx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rcx, -0x1 ; moving imm to reg
movzx r10, r10b
adox r10, rcx; loading flag
adox r12, [ rsp + 0x418 ]
mov r10, 0x6cfc5fd681c52056 ; moving imm to reg
xchg rdx, r10; 0x6cfc5fd681c52056, swapping with x6, which is currently in rdx
mov [ rsp + 0x438 ], rbx; spilling x606 to mem
mulx rcx, rbx, r13; x559, x558<- x540 * 0x6cfc5fd681c52056
setc dl; spill CF x607 to reg (rdx)
clc;
mov [ rsp + 0x440 ], rcx; spilling x559 to mem
mov rcx, -0x1 ; moving imm to reg
movzx r14, r14b
adcx r14, rcx; loading flag
adcx r12, [ rsp + 0x3c0 ]
seto r14b; spill OF x536 to reg (r14)
movzx rcx, byte [ rsp + 0x430 ]; load byte memx577 to register64
mov byte [ rsp + 0x448 ], dl; spilling byte x607 to mem
mov rdx, -0x1 ; moving imm to reg
inc rdx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rdx, -0x1 ; moving imm to reg
adox rcx, rdx; loading flag
adox rbx, [ rsp + 0x420 ]
setc cl; spill CF x551 to reg (rcx)
clc;
movzx r15, r15b
adcx r15, rdx; loading flag
adcx r12, rbx
setc r15b; spill CF x594 to reg (r15)
seto bl; spill OF x579 to reg (rbx)
movzx rdx, byte [ rsp + 0x448 ]; x607, copying x607 here, cause x607 is needed in a reg for other than x607, namely all: , x608--x609, size: 1
add rdx, -0x1
mov byte [ rsp + 0x450 ], cl; spilling byte x551 to mem
mov rcx, r12; x608, copying x593 here, cause x593 is needed in a reg for other than x608, namely all: , x608--x609, x620, size: 2
mov byte [ rsp + 0x458 ], r14b; spilling byte x536 to mem
mov r14, 0x7bc65c783158aea3 ; moving imm to reg
sbb rcx, r14
mov rdx, r10; x6 to rdx
mulx rdx, r10, [ rax + 0x30 ]; x514, x513<- x6 * arg2[6]
movzx r14, byte [ rsp + 0x458 ]; load byte memx536 to register64
mov [ rsp + 0x460 ], rcx; spilling x608 to mem
mov rcx, -0x1 ; moving imm to reg
inc rcx; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rcx, -0x1 ; moving imm to reg
adox r14, rcx; loading flag
adox r10, [ rsp + 0x428 ]
seto r14b; spill OF x538 to reg (r14)
movzx rcx, byte [ rsp + 0x450 ]; load byte memx551 to register64
mov [ rsp + 0x468 ], rdx; spilling x514 to mem
mov rdx, 0x0 ; moving imm to reg
dec rdx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
adox rcx, rdx; loading flag
adox r10, [ rsp + 0x3b8 ]
mov rcx, 0x2341f27177344 ; moving imm to reg
mov rdx, r13; x540 to rdx
mulx rdx, r13, rcx; x557, x556<- x540 * 0x2341f27177344
seto cl; spill OF x553 to reg (rcx)
mov [ rsp + 0x470 ], rdx; spilling x557 to mem
mov rdx, 0x0 ; moving imm to reg
dec rdx; OF<-0x0, preserve CF (debug: state 4 (thanks Paul))
movzx rbx, bl
adox rbx, rdx; loading flag
adox r13, [ rsp + 0x440 ]
seto bl; spill OF x581 to reg (rbx)
inc rdx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rdx, -0x1 ; moving imm to reg
movzx r15, r15b
adox r15, rdx; loading flag
adox r10, r13
movzx r15, r14b; x539, copying x538 here, cause x538 is needed in a reg for other than x539, namely all: , x539, size: 1
mov r13, [ rsp + 0x468 ]; load m64 x514 to register64
lea r15, [ r15 + r13 ]; r8/64 + m8
seto r13b; spill OF x596 to reg (r13)
mov r14, r10; x610, copying x595 here, cause x595 is needed in a reg for other than x610, namely all: , x621, x610--x611, size: 2
mov rdx, 0x6cfc5fd681c52056 ; moving imm to reg
sbb r14, rdx
movzx rdx, bl; x582, copying x581 here, cause x581 is needed in a reg for other than x582, namely all: , x582, size: 1
mov [ rsp + 0x478 ], r14; spilling x610 to mem
mov r14, [ rsp + 0x470 ]; load m64 x557 to register64
lea rdx, [ rdx + r14 ]; r8/64 + m8
mov r14, -0x1 ; moving imm to reg
inc r14; OF<-0x0, preserve CF (debug: state 5 (thanks Paul))
mov rbx, -0x1 ; moving imm to reg
movzx r14, byte [ rsp + 0x3b0 ]; load byte memx512 to register64
movzx rcx, cl
adox rcx, rbx; loading flag
adox r15, r14
seto r14b; spill OF x555 to reg (r14)
inc rbx; OF<-0x0, preserve CF (debug: state 2 (y: -1, n: 0))
mov rcx, -0x1 ; moving imm to reg
movzx r13, r13b
adox r13, rcx; loading flag
adox r15, rdx
seto r13b; spill OF x598 to reg (r13)
mov rdx, r15; x612, copying x597 here, cause x597 is needed in a reg for other than x612, namely all: , x612--x613, x622, size: 2
mov rbx, 0x2341f27177344 ; moving imm to reg
sbb rdx, rbx
movzx rcx, r13b; x599, copying x598 here, cause x598 is needed in a reg for other than x599, namely all: , x599, size: 1
movzx r14, r14b
lea rcx, [ rcx + r14 ]
sbb rcx, 0x00000000
mov rcx, [ rsp + 0x478 ]; x621, copying x610 here, cause x610 is needed in a reg for other than x621, namely all: , x621, size: 1
cmovc rcx, r10; if CF, x621<- x595 (nzVar)
mov r10, [ rsp + 0x0 ]; load m64 out1 to register64
mov [ r10 + 0x28 ], rcx; out1[5] = x621
mov r14, [ rsp + 0x408 ]; x618, copying x604 here, cause x604 is needed in a reg for other than x618, namely all: , x618, size: 1
cmovc r14, r9; if CF, x618<- x589 (nzVar)
mov r9, [ rsp + 0x400 ]; x617, copying x602 here, cause x602 is needed in a reg for other than x617, namely all: , x617, size: 1
cmovc r9, r8; if CF, x617<- x587 (nzVar)
mov r8, [ rsp + 0x3d0 ]; x616, copying x600 here, cause x600 is needed in a reg for other than x616, namely all: , x616, size: 1
cmovc r8, rbp; if CF, x616<- x585 (nzVar)
mov [ r10 + 0x8 ], r9; out1[1] = x617
mov [ r10 + 0x0 ], r8; out1[0] = x616
mov rbp, [ rsp + 0x438 ]; x619, copying x606 here, cause x606 is needed in a reg for other than x619, namely all: , x619, size: 1
cmovc rbp, r11; if CF, x619<- x591 (nzVar)
cmovc rdx, r15; if CF, x622<- x597 (nzVar)
mov [ r10 + 0x18 ], rbp; out1[3] = x619
mov r11, [ rsp + 0x460 ]; x620, copying x608 here, cause x608 is needed in a reg for other than x620, namely all: , x620, size: 1
cmovc r11, r12; if CF, x620<- x593 (nzVar)
mov [ r10 + 0x10 ], r14; out1[2] = x618
mov [ r10 + 0x30 ], rdx; out1[6] = x622
mov [ r10 + 0x20 ], r11; out1[4] = x620
mov rbx, [ rsp + 0x480 ]; restoring from stack
mov rbp, [ rsp + 0x488 ]; restoring from stack
mov r12, [ rsp + 0x490 ]; restoring from stack
mov r13, [ rsp + 0x498 ]; restoring from stack
mov r14, [ rsp + 0x4a0 ]; restoring from stack
mov r15, [ rsp + 0x4a8 ]; restoring from stack
add rsp, 0x4b0
ret
; cpu 11th Gen Intel(R) Core(TM) i7-11700KF @ 3.60GHz
; clocked at 3600 MHz
; first cyclecount 346.145, best 342.36, lastGood 394.4230769230769
; seed 2529639215636402
; CC / CFLAGS clang / -march=native -mtune=native -O3
; time needed: 37037 ms / 500 runs=> 74.074ms/run
; Time spent for assembling and measureing (initial batch_size=27, initial num_batches=101): 971 ms
; Ratio (time for assembling + measure)/(total runtime for 500runs): 0.026217026217026217
; number reverted permutation/ tried permutation: 139 / 255 =54.510%
; number reverted decision/ tried decision: 113 / 246 =45.935% |
oeis/083/A083880.asm | neoneye/loda-programs | 11 | 88448 | <reponame>neoneye/loda-programs
; A083880: a(0)=1, a(1)=5, a(n) = 10*a(n-1) - 23*a(n-2), n >= 2.
; Submitted by <NAME>(s3)
; 1,5,27,155,929,5725,35883,227155,1446241,9237845,59114907,378678635,2427143489,15561826285,99793962603,640017621475,4104915074881,26328745454885,168874407826587,1083182932803515,6947717948023649
mov $1,1
lpb $0
sub $0,1
mov $2,$3
mul $3,4
add $3,$1
mul $1,6
add $1,$2
lpe
sub $1,$3
mov $0,$1
|
codigo/capitulo 36/arreglodowhile.asm | codeneomatrix/ENSAMBLADOR-x86-ACEVEDO | 1 | 98724 | segment .data
arre db '45', '23', '11', '09' ; estos datos se almacenan como
; bytes en memoria, de forma consecutiva
len equ $-arre
ln db 10,13
lenln equ $-ln
segment .text
global _start
_start:
mov ebp, arre ;guardamos la direccion de memoria en el registro ebp
mov edi, 1 ; guardamos el numero que nos servira de contador en el
; registro edi
ciclo:
mov eax, 4
mov ebx, 0
mov ecx, ebp ; copiamos a ecx la direccion de memoria que esta
; almacenado en el registro ebp, de esa direccion de memoria
; es de donde se comenzara a imprimir
mov edx, 2 ; enviamos a imprimir 2 bytes a la pantalla
int 80h
mov eax, 4
mov ebx, 0
mov ecx, ln
mov edx, lenln
int 80h
add ebp,2 ; aumentamos en dos el valor de la direccion de memoria
; con el fin de obtener el "segundo" elemento del arreglo "23"
; esto porque el "primer" elemento es "45" un numero de dos
; elementos
add edi, 2 ; aumentamos en dos el valor del contador
cmp edi,len ; preguntamos si ya hemos impreso todos los
; datos del arreglo
jb ciclo ; si aun faltan datos por imprimir repetimos
; el ciclo de nuevo
salir:
mov eax, 1
xor ebx, ebx
int 0x80 |
programs/oeis/014/A014771.asm | neoneye/loda | 22 | 6488 | ; A014771: Squares of odd hexagonal numbers.
; 1,225,2025,8281,23409,53361,105625,189225,314721,494209,741321,1071225,1500625,2047761,2732409,3575881,4601025,5832225,7295401,9018009,11029041,13359025,16040025,19105641,22591009,26532801,30969225,35940025,41486481,47651409,54479161,62015625,70308225,79405921,89359209,100220121,112042225,124880625,138791961,153834409,170067681,187553025,206353225,226532601,248157009,271293841,296012025,322382025,350475841,380367009,412130601,445843225,481583025,519429681,559464409,601769961,646430625,693532225,743162121,795409209,850363921,908118225,968765625,1032401161,1099121409,1169024481,1242210025,1318779225,1398834801,1482481009,1569823641,1660970025,1756029025,1855111041,1958328009,2065793401,2177622225,2293931025,2414837881,2540462409,2670925761,2806350625,2946861225,3092583321,3243644209,3400172721,3562299225,3730155625,3903875361,4083593409,4269446281,4461572025,4660110225,4865202001,5076990009,5295618441,5521233025,5753981025,5994011241,6241474009
mul $0,4
add $0,2
bin $0,2
pow $0,2
|
FlameOS 2.0/KernelParts/GDT.asm | Th3Matt/FlameOS | 0 | 4863 | ;---------------------00 - NULL
mov edi, GDTTableLoc
mov dword [edi], 0
add edi, 4
mov dword [edi], 0
add edi, 4
;---------------------08 - Stack
;500 - 1500
mov ax, 0x14ff
mov [edi], ax
add edi, 2
push ax
mov ax, 0x500
mov [edi], ax
pop ax
add edi, 2
xor ecx, ecx
mov ch, 01010000b
shl ecx, 8
mov ch, 10010010b
mov [edi], ecx
add edi, 4
;---------------------10 - TSS
;1500 - 1564
add ax, 0x65
mov word [edi], 0x64
add edi, 2
push ax
sub ax, 0x64
mov [edi], ax
pop ax
add edi, 2
xor ecx, ecx
mov ch, 0x40
shl ecx, 8
mov ch, 0x89
mov [edi], ecx
add edi, 4
;----------------------18 - Kernel Data
;1565 - 145ff
add ax, 0x4600-0x64-0x1500-1
mov [edi], ax
add edi, 2
push ax
sub ax, 0x4600-0x64-0x1500-2
mov [edi], ax
pop ax
add edi, 2
xor ecx, ecx
mov ch, 01010001b
shl ecx, 8
mov ch, 10010010b
mov [edi], ecx
add edi, 4
inc ax
mov bx, ax ;---------------------20 - Kernel Code
;14600 - 159ff
add ax, 0x13FF
mov [edi], ax
add edi, 2
mov [edi], bx
add edi, 2
xor ecx, ecx
mov ch, 01010001b
shl ecx, 8
mov ch, 10011010b
mov cl, 1
mov [edi], ecx
add edi, 4 ;---------------------28 - Screen
;b8000 - bffff
mov bx, 0x8000
mov ax, 0xFFFF
mov [edi], ax
add edi, 2
mov [edi], bx
add edi, 2
xor ecx, ecx
mov ch, 01011011b
shl ecx, 8
mov ch, 10010010b
mov cl, 0xB
mov [edi], ecx
add edi, 4 ;---------------------30 - Hookpoints
;14300 - 145ff
mov bx, 0x4300
mov ax, 0x45ff
mov [edi], ax
add edi, 2
mov [edi], bx
add edi, 2
xor ecx, ecx
mov ch, 01010001b
shl ecx, 8
mov ch, 10010010b
mov cl, 0x1
mov [edi], ecx
add edi, 4 ;---------------------38 - VidBuffer Pointers
;15a00 - 15fff
mov bx, 0x5A00
mov ax, 0x5FFF
mov [edi], ax
add edi, 2
mov [edi], bx
add edi, 2
xor ecx, ecx
mov ch, 01010001b
shl ecx, 8
mov ch, 10010010b
mov cl, 0x1
mov [edi], ecx
add edi, 4 ;---------------------40 - USER Data
;100000 - ffffffff
mov bx, 0x0000
mov ax, 0xFFFF
mov [edi], ax
add edi, 2
mov [edi], bx
add edi, 2
xor ecx, ecx
mov ch, 11011111b
shl ecx, 8
mov ch, 10010010b
mov cl, 0x10
mov [edi], ecx
add edi, 4 ;---------------------48 - USER Code
;100000 - ffffffff
mov bx, 0x0000
mov ax, 0xFFFF
mov [edi], ax
add edi, 2
mov [edi], bx
add edi, 2
xor ecx, ecx
mov ch, 11011111b
shl ecx, 8
mov ch, 10011010b
mov cl, 0x10
mov [edi], ecx
add edi, 4 ;---------------------
mov esi, edi
sub esi, GDTTableLoc
dec esi
mov [edi], si
mov eax, edi
add edi, 2
mov dword [edi], GDTTableLoc
xchg bx, bx
lgdt [eax]
jmp 0x20:ReloadGDT
ReloadGDT:
|
source/featuremap_xl.applescript | mckryton/featuremap_xl | 2 | 2409 | --------------------------------------------------------------------------
-- Description : io functionality for MAC Excel 2016 makro featuremap_xl
--------------------------------------------------------------------------
-- Copyright 2016 <NAME>
--
-- 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.
-----------------------------------------------------------------------------------------
-- description: ask user where to expect the .feature files
-- parameters: pDummy - it seems that Excel 2016 expect all funtions to have exact one parameter
-- return value: has to be a string
-----------------------------------------------------------------------------------------
on chooseFeatureFolder(pDummy)
try
tell application "Finder"
application activate
set vPath to (choose folder with prompt "choose feature folder" default location (path to the desktop folder from user domain))
return URL of vPath & "#@#@" & displayed name of disk of vPath
end tell
on error
return ""
end try
end chooseFeatureFolder
-----------------------------------------------------------------------------------------
-- description: read file names from the feature folder
-- parameters: pFeatureFolderPath - the directory containing all .feature files
-- return value: the .feature file names as string
-----------------------------------------------------------------------------------------
on getFeatureFileNames(pFeatureFolderPath)
set vFeatureFileNames to {}
tell application "Finder"
set vFeaturesFolder to pFeatureFolderPath as alias
set vFeatureFiles to (get files of vFeaturesFolder whose name ends with ".feature")
repeat with vFeatureFile in vFeatureFiles
set end of vFeatureFileNames to get URL of vFeatureFile
end repeat
end tell
set AppleScript's text item delimiters to "#@#@"
return vFeatureFileNames as string
end getFeatureFileNames
-----------------------------------------------------------------------------------------
-- description: read the content from a given single .feature file
-- parameters: pFeatureFilePath - the full path for a single .feature file
-- return value: the content of the .feature file in one line
-----------------------------------------------------------------------------------------
on readFeatureFile(pFeatureFilePath)
local vOldTextDelimiters
local vFeatureText
local vErrDialog, vUserChoiceOnErr
try
set vOldTextDelimiters to AppleScript's text item delimiters
set AppleScript's text item delimiters to "#@#@"
set vFeatureText to (paragraphs of (read (pFeatureFilePath as alias) as «class utf8»)) as string
set AppleScript's text item delimiters to vOldTextDelimiters
return vFeatureText
on error
set vErrDialog to display dialog "could not read feature file >" & pFeatureFilePath & "<" default button "continue" buttons {"cancel", "continue"} with icon caution
if button returned of vErrDialog is "cancel" then
return "cancel" as string
else
return "" as string
end if
end try
end readFeatureFile
|
prototyping/Luau/Substitution.agda | Tr4shh/Roblox-Luau | 0 | 5681 | module Luau.Substitution where
open import Luau.Syntax using (Expr; Stat; Block; nil; addr; var; function_is_end; _$_; block_is_end; local_←_; _∙_; done; return; _⟨_⟩ ; name; fun; arg; number; binexp)
open import Luau.Value using (Value; val)
open import Luau.Var using (Var; _≡ⱽ_)
open import Properties.Dec using (Dec; yes; no)
_[_/_]ᴱ : ∀ {a} → Expr a → Value → Var → Expr a
_[_/_]ᴮ : ∀ {a} → Block a → Value → Var → Block a
var_[_/_]ᴱwhenever_ : ∀ {a P} → Var → Value → Var → (Dec P) → Expr a
_[_/_]ᴮunless_ : ∀ {a P} → Block a → Value → Var → (Dec P) → Block a
nil [ v / x ]ᴱ = nil
var y [ v / x ]ᴱ = var y [ v / x ]ᴱwhenever (x ≡ⱽ y)
addr a [ v / x ]ᴱ = addr a
(number y) [ v / x ]ᴱ = number y
(M $ N) [ v / x ]ᴱ = (M [ v / x ]ᴱ) $ (N [ v / x ]ᴱ)
function F is C end [ v / x ]ᴱ = function F is C [ v / x ]ᴮunless (x ≡ⱽ name(arg F)) end
block b is C end [ v / x ]ᴱ = block b is C [ v / x ]ᴮ end
(binexp e₁ op e₂) [ v / x ]ᴱ = binexp (e₁ [ v / x ]ᴱ) op (e₂ [ v / x ]ᴱ)
(function F is C end ∙ B) [ v / x ]ᴮ = function F is (C [ v / x ]ᴮunless (x ≡ⱽ name(arg F))) end ∙ (B [ v / x ]ᴮunless (x ≡ⱽ fun F))
(local y ← M ∙ B) [ v / x ]ᴮ = local y ← (M [ v / x ]ᴱ) ∙ (B [ v / x ]ᴮunless (x ≡ⱽ name y))
(return M ∙ B) [ v / x ]ᴮ = return (M [ v / x ]ᴱ) ∙ (B [ v / x ]ᴮ)
done [ v / x ]ᴮ = done
var y [ v / x ]ᴱwhenever yes p = val v
var y [ v / x ]ᴱwhenever no p = var y
B [ v / x ]ᴮunless yes p = B
B [ v / x ]ᴮunless no p = B [ v / x ]ᴮ
|
Validation/pyFrame3DD-master/gcc-master/gcc/ada/libgnat/a-stoufo.ads | djamal2727/Main-Bearing-Analytical-Model | 0 | 25930 | ------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- ADA.STRINGS.TEXT_OUTPUT.FORMATTING --
-- --
-- S p e c --
-- --
-- Copyright (C) 2020, Free Software Foundation, Inc. --
-- --
-- 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. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- 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 was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
package Ada.Strings.Text_Output.Formatting is
-- Template-based output, based loosely on C's printf family. Unlike
-- printf, it is type safe. We don't support myriad formatting options; the
-- caller is expected to call 'Image, or other functions that might have
-- various formatting capabilities.
--
-- Each of the following calls Flush
type Template is new UTF_8;
procedure Put
(S : in out Sink'Class; T : Template;
X1, X2, X3, X4, X5, X6, X7, X8, X9 : UTF_8_Lines := "");
-- Prints the template as is, except for the following escape sequences:
-- "\n" is end of line.
-- "\i" indents by the default amount, and "\o" outdents.
-- "\I" indents by one space, and "\O" outdents.
-- "\1" is replaced with X1, and similarly for 2, 3, ....
-- "\\" is "\".
-- Note that the template is not type String, to avoid this sort of thing:
--
-- https://xkcd.com/327/
procedure Put
(T : Template;
X1, X2, X3, X4, X5, X6, X7, X8, X9 : UTF_8_Lines := "");
-- Sends to standard output
procedure Err
(T : Template;
X1, X2, X3, X4, X5, X6, X7, X8, X9 : UTF_8_Lines := "");
-- Sends to standard error
function Format
(T : Template;
X1, X2, X3, X4, X5, X6, X7, X8, X9 : UTF_8_Lines := "")
return UTF_8_Lines;
-- Returns a UTF-8-encoded String
end Ada.Strings.Text_Output.Formatting;
|
programs/oeis/168/A168398.asm | karttu/loda | 1 | 5273 | ; A168398: a(n) = 4 + 8*floor((n-1)/2).
; 4,4,12,12,20,20,28,28,36,36,44,44,52,52,60,60,68,68,76,76,84,84,92,92,100,100,108,108,116,116,124,124,132,132,140,140,148,148,156,156,164,164,172,172,180,180,188,188,196,196,204,204,212,212,220,220,228,228,236,236,244,244,252,252,260,260,268,268,276,276,284,284,292,292,300,300,308,308,316,316,324,324,332,332,340,340,348,348,356,356,364,364,372,372,380,380,388,388,396,396,404,404,412,412,420,420,428,428,436,436,444,444,452,452,460,460,468,468,476,476,484,484,492,492,500,500,508,508,516,516,524,524,532,532,540,540,548,548,556,556,564,564,572,572,580,580,588,588,596,596,604,604,612,612,620,620,628,628,636,636,644,644,652,652,660,660,668,668,676,676,684,684,692,692,700,700,708,708,716,716,724,724,732,732,740,740,748,748,756,756,764,764,772,772,780,780,788,788,796,796,804,804,812,812,820,820,828,828,836,836,844,844,852,852,860,860,868,868,876,876,884,884,892,892,900,900,908,908,916,916,924,924,932,932,940,940,948,948,956,956,964,964,972,972,980,980,988,988,996,996
mov $1,$0
div $1,2
mul $1,8
add $1,4
|
image_random.ads | jrcarter/Image_Random | 1 | 7028 | -- Image_Random: True random numbers from a digital camera
-- This works under Linux with the GNAT compiler; modification for other platforms or compilers is left as an exercise for the
-- despearate
-- Ideally, the camera should have its lens cap on, or have a similar dark covering, so the image is of the camera sensor noise
-- However, another randomly changing scene, such as a lava lamp or aquarium, may also work
-- This is slow and only produces 64 random bytes; if you need more, it is probably best to use these bytes to seed a high-quality
-- pseudo-random number generator, such as the Threefry generator
-- Copyright (C) 2020 by Pragmada Software Engineering
-- Released under the terms of the BSD 3-Clause license; see https://opensource.org/licenses
--
-- 2020-09-01 Initial version
--
with Ada.Streams;
package Image_Random is
function Random return Ada.Streams.Stream_Element_Array;
-- Captures an image from the default image device to file random.png using jswebcam, reads random.png as a Stream_Element_Array,
-- and returns the SHA-512 hash of the data read
-- Raises Program_Error if capturing the image fails
end Image_Random;
|
programs/oeis/274/A274431.asm | karttu/loda | 0 | 169966 | ; A274431: Positions in A274426 of products of distinct Lucas numbers > 1 (excluding 2).
; 1,2,4,6,7,10,11,14,15,16,20,21,22,26,27,28,29,34,35,36,37,42,43,44,45,46,52,53,54,55,56,62,63,64,65,66,67,74,75,76,77,78,79,86,87,88,89,90,91,92,100,101,102,103,104,105,106,114,115,116,117,118,119
mov $4,$0
add $4,1
mov $9,$0
lpb $4,1
mov $0,$9
sub $4,1
sub $0,$4
mov $5,$0
mov $7,2
lpb $7,1
mov $0,$5
sub $7,1
add $0,$7
sub $0,1
mov $10,$0
sub $10,$0
mul $0,2
lpb $0,1
sub $0,$3
mov $2,$3
div $2,2
add $3,1
add $10,$2
lpe
mov $2,$3
sub $3,2
sub $10,$3
mov $3,1
mov $8,$7
add $10,$2
mul $10,5
sub $10,9
div $10,5
lpb $8,1
mov $6,$10
sub $8,1
lpe
lpe
lpb $5,1
mov $5,0
sub $6,$10
lpe
mov $10,$6
add $10,1
add $1,$10
lpe
|
src/features/paging/fault_handler.asm | FranchuFranchu/fran-os | 1 | 171611 | <reponame>FranchuFranchu/fran-os<filename>src/features/paging/fault_handler.asm<gh_stars>1-10
; IN = EAX: Error code
kernel_exception_handler_page_fault:
test eax, 0x1
jnz .protection_fault
jz .nonpresent
.nonpresent:
; Load an extra page for the program
mov ebx, cr2
cmp ebx, KERNEL_VIRTUAL_BASE ; 0xC0000000
jl .kernelspace
jg .userspace
.kernelspace:
; Most likely an error
; We haven't implemented page swapping yet
jmp .bad_end
.userspace:
; TODO
; this could recursively call itself until it reaches the user page
; very bad
; but works
; call kernel_paging_new_user_page
jmp .bad_end
.protection_fault:
; Simply stop the program
; TODO
jmp .bad_end
.bad_end:
push eax
call kernel_terminal_clear_screen
mov esi, .errmsg
mov edi, VGA_BUFFER
mov bl, 0x4F
call kernel_exception_handler_print_string
; Print error code
pop eax
mov byte [kernel_terminal_row], 10
call kernel_debug_print_eax
mov ebx, cr2
mov eax, ebx
call kernel_debug_print_eax
call kernel_exception_fault
jmp kernel_halt
.errmsg: db "Page fault", 0
.end:
ret |
EEL7030/Laboratorio 2/Parte2/addvect.asm | GSimas/MicroC | 0 | 28931 | <gh_stars>0
;Programa ADDVECT.asm
RESET EQU 0H
VETOR EQU 60H
ORG RESET ; PC = 0000H ao se resetar o 8051
MOV DPTR,#NRO ; endereco nro parcelas a ser somado
MOV A,#0
MOVC A,@A+DPTR
JZ FIM
MOV R1,A ; R1 = nro parcelas a ser somado
MOV DPTR,#DADOS ; end. vetor de dados a ser somado
MOV R2,#0 ; guarda resultado das somas realizadas
MOV R0,#0 ; especifica parcela a ser lida do vetor de dados
MOV R3,#0
VOLTA: MOV A,R0
MOVC A,@A+DPTR ; le parcela
ADD A,R2
MOV R2,A
MOV DPTR,#0001H ;define endereco memoria externa (x:01)
MOVX @DPTR,A ;salva na memoria externa o conteudo do acumulador
MOV A,#0
ADDC A,R3
MOV R3,A
INC R0
DJNZ R1,VOLTA
FIM: JMP FIM
ORG VETOR
NRO: DB 06H
DADOS: DB 01H,03H,05H,36H,0DAH,0E2H
END |
utils/yangutils/plugin/src/main/resources/YangLexer.g4 | VinodKumarS-Huawei/ietf96yang | 0 | 521 | <reponame>VinodKumarS-Huawei/ietf96yang<filename>utils/yangutils/plugin/src/main/resources/YangLexer.g4<gh_stars>0
/*
* Copyright 2016-present Open Networking Laboratory
*
* 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.
*/
/**
* This is a YANG grammar for lexer based on which ANTLR will generate YANG lexer.
*/
lexer grammar YangLexer;
// Statements keywords
ANYXML_KEYWORD : 'anyxml';
ARGUMENT_KEYWORD : 'argument';
AUGMENT_KEYWORD : 'augment';
BASE_KEYWORD : 'base';
BELONGS_TO_KEYWORD : 'belongs-to';
BIT_KEYWORD : 'bit';
CASE_KEYWORD : 'case';
CHOICE_KEYWORD : 'choice';
CONFIG_KEYWORD : 'config';
CONTACT_KEYWORD : 'contact';
CONTAINER_KEYWORD : 'container';
DEFAULT_KEYWORD : 'default';
DESCRIPTION_KEYWORD : 'description';
ENUM_KEYWORD : 'enum';
ERROR_APP_TAG_KEYWORD : 'error-app-tag';
ERROR_MESSAGE_KEYWORD : 'error-message';
EXTENSION_KEYWORD : 'extension';
DEVIATION_KEYWORD : 'deviation';
DEVIATE_KEYWORD : 'deviate';
FEATURE_KEYWORD : 'feature';
FRACTION_DIGITS_KEYWORD : 'fraction-digits';
GROUPING_KEYWORD : 'grouping';
IDENTITY_KEYWORD : 'identity';
IF_FEATURE_KEYWORD : 'if-feature';
IMPORT_KEYWORD : 'import';
INCLUDE_KEYWORD : 'include';
INPUT_KEYWORD : 'input';
KEY_KEYWORD : 'key';
LEAF_KEYWORD : 'leaf';
LEAF_LIST_KEYWORD : 'leaf-list';
LENGTH_KEYWORD : 'length';
LIST_KEYWORD : 'list';
MANDATORY_KEYWORD : 'mandatory';
MAX_ELEMENTS_KEYWORD : 'max-elements';
MIN_ELEMENTS_KEYWORD : 'min-elements';
MODULE_KEYWORD : 'module';
MUST_KEYWORD : 'must';
NAMESPACE_KEYWORD : 'namespace';
NOTIFICATION_KEYWORD: 'notification';
ORDERED_BY_KEYWORD : 'ordered-by';
ORGANIZATION_KEYWORD: 'organization';
OUTPUT_KEYWORD : 'output';
PATH_KEYWORD : 'path';
PATTERN_KEYWORD : 'pattern';
POSITION_KEYWORD : 'position';
PREFIX_KEYWORD : 'prefix';
PRESENCE_KEYWORD : 'presence';
RANGE_KEYWORD : 'range';
REFERENCE_KEYWORD : 'reference';
REFINE_KEYWORD : 'refine';
REQUIRE_INSTANCE_KEYWORD : 'require-instance';
REVISION_KEYWORD : 'revision';
REVISION_DATE_KEYWORD : 'revision-date';
RPC_KEYWORD : 'rpc';
STATUS_KEYWORD : 'status';
SUBMODULE_KEYWORD : 'submodule';
TYPE_KEYWORD : 'type';
TYPEDEF_KEYWORD : 'typedef';
UNIQUE_KEYWORD : 'unique';
UNITS_KEYWORD : 'units';
USES_KEYWORD : 'uses';
VALUE_KEYWORD : 'value';
WHEN_KEYWORD : 'when';
YANG_VERSION_KEYWORD: 'yang-version';
YIN_ELEMENT_KEYWORD : 'yin-element';
ADD_KEYWORD : 'add';
CURRENT_KEYWORD : 'current';
DELETE_KEYWORD : 'delete';
DEPRECATED_KEYWORD : 'deprecated';
FALSE_KEYWORD : 'false';
MAX_KEYWORD : 'max';
MIN_KEYWORD : 'min';
NOT_SUPPORTED_KEYWORD : 'not-supported';
OBSOLETE_KEYWORD : 'obsolete';
REPLACE_KEYWORD : 'replace';
SYSTEM_KEYWORD : 'system';
TRUE_KEYWORD : 'true';
UNBOUNDED_KEYWORD : 'unbounded';
USER_KEYWORD : 'user';
COMPILER_ANNOTATION_KEYWORD : 'compiler-annotation';
COMPILER_ANNOTATION : IDENTIFIER COLON COMPILER_ANNOTATION_KEYWORD;
APP_DATA_STRUCTURE_KEYWORD : 'app-data-structure';
APP_DATA_STRUCTURE : IDENTIFIER COLON APP_DATA_STRUCTURE_KEYWORD;
DATA_STRUCTURE_KEYWORD : 'data-structure';
DATA_STRUCTURE : IDENTIFIER COLON DATA_STRUCTURE_KEYWORD;
DATA_STRUCTURE_KEY : IDENTIFIER COLON KEY_KEYWORD;
APP_EXTENDED_KEYWORD : 'app-extended-name';
APP_EXTENDED : IDENTIFIER COLON APP_EXTENDED_KEYWORD;
// Lexer tokens to be skipped
COMMENT
: '/*' .*? '*/' -> channel(HIDDEN)
;
WS : [ \r\t\u000C\n]+ -> channel(HIDDEN)
;
LINE_COMMENT
: '//' ~[\r\n]* '\r'? '\n' -> channel(HIDDEN)
;
// Additional rules
INTEGER : DIGIT+;
DATE_ARG : DIGIT DIGIT DIGIT DIGIT '-' DIGIT DIGIT '-' DIGIT DIGIT;
LEFT_CURLY_BRACE : '{';
RIGHT_CURLY_BRACE : '}';
IDENTIFIER : (ALPHA | '_')
(ALPHA | DIGIT | '_' | '-' | '.')*;
STMTEND : ';';
DQUOTE : '"';
COLON : ':';
PLUS : '+';
MINUS: '-';
STRING : ((~( '\r' | '\n' | '\t' | ' ' | ';' | '{' | '"' | '\'')~( '\r' | '\n' | '\t' | ' ' | ';' | '{' )* ) | SUB_STRING );
//Fragment rules
fragment SUB_STRING : ('"' (ESC | ~["])*'"') | ('\'' (ESC | ~['])*'\'') ;
fragment ESC : '\\' (["\\/bfnrt] | UNICODE) ;
fragment UNICODE : 'u' HEX HEX HEX HEX ;
fragment HEX : [0-9a-fA-F] ;
fragment ALPHA : [A-Za-z];
fragment DIGIT : [0-9];
fragment URN : [u][r][n];
fragment HTTP : [h][t][t][p]; |
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/cd/cd5014x.ada | best08618/asylo | 7 | 667 | <gh_stars>1-10
-- CD5014X.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.
--*
-- OBJECTIVE:
-- CHECK THAT AN ADDRESS CLAUSE CAN BE GIVEN IN THE PRIVATE PART
-- OF A GENERIC PACKAGE SPECIFICATION FOR A VARIABLE OF A FORMAL
-- ARRAY TYPE, WHERE THE VARIABLE IS DECLARED IN THE VISIBLE PART
-- OF THE SPECIFICATION.
-- HISTORY:
-- BCB 10/08/87 CREATED ORIGINAL TEST.
-- PWB 05/11/89 CHANGED EXTENSION FROM '.DEP' TO '.ADA'.
WITH SYSTEM; USE SYSTEM;
WITH SPPRT13; USE SPPRT13;
WITH REPORT; USE REPORT;
WITH TEXT_IO; USE TEXT_IO;
PROCEDURE CD5014X IS
BEGIN
TEST ("CD5014X", " AN ADDRESS CLAUSE CAN BE GIVEN " &
"IN THE PRIVATE PART OF A GENERIC PACKAGE " &
"SPECIFICATION FOR A VARIABLE OF A FORMAL " &
"ARRAY TYPE, WHERE THE VARIABLE IS DECLARED " &
"IN THE VISIBLE PART OF THE SPECIFICATION");
DECLARE
TYPE COLOR IS (RED,BLUE,GREEN);
TYPE COLOR_TABLE IS ARRAY (COLOR) OF INTEGER;
GENERIC
TYPE INDEX IS (<>);
TYPE FORM_ARRAY_TYPE IS ARRAY (INDEX) OF INTEGER;
PACKAGE PKG IS
FORM_ARRAY_OBJ1 : FORM_ARRAY_TYPE := (1,2,3);
PRIVATE
FOR FORM_ARRAY_OBJ1 USE AT VARIABLE_ADDRESS;
END PKG;
PACKAGE BODY PKG IS
BEGIN
IF EQUAL(3,3) THEN
FORM_ARRAY_OBJ1 := (10,20,30);
END IF;
IF FORM_ARRAY_OBJ1 /= (10,20,30) THEN
FAILED ("INCORRECT VALUE FOR FORMAL ARRAY VARIABLE");
END IF;
IF FORM_ARRAY_OBJ1'ADDRESS /= VARIABLE_ADDRESS THEN
FAILED ("INCORRECT ADDRESS FOR FORMAL ARRAY " &
"VARIABLE");
END IF;
END PKG;
PACKAGE PACK IS NEW PKG(INDEX => COLOR,
FORM_ARRAY_TYPE => COLOR_TABLE);
BEGIN
NULL;
END;
RESULT;
END CD5014X;
|
oeis/019/A019756.asm | neoneye/loda-programs | 11 | 3407 | <filename>oeis/019/A019756.asm<gh_stars>10-100
; A019756: Decimal expansion of e/19.
; Submitted by <NAME>(s4)
; 1,4,3,0,6,7,4,6,4,6,5,5,7,3,9,2,2,2,9,1,3,6,9,9,3,4,0,5,9,7,5,0,8,5,5,2,5,1,3,5,3,9,3,2,0,7,2,1,0,5,0,5,0,3,9,4,5,6,2,9,8,7,5,1,4,3,3,7,2,4,5,4,2,2,9,1,3,4,0,8,3,9,2,4,8,0,9,5,8,8,3,4,3,4,2,9,8,1,1,9
add $0,1
seq $0,11543 ; Decimal expansion of e truncated to n places.
div $0,19
mod $0,10
|
programs/oeis/115/A115536.asm | karttu/loda | 1 | 19654 | ; A115536: Numbers n such that the square of n is the concatenation of two numbers m and 4*m.
; 160378,169812,179246,188680,198114,207548,216982,226416,235850,245284,254718,264152,273586,283020,292454,301888,311322,320756,330190,339624,349058,358492,367926,377360,386794,396228,405662
mov $1,$0
mul $1,9434
add $1,160378
|
source/code_count.adb | xiashuangxi/codecount | 0 | 17095 | <reponame>xiashuangxi/codecount
package body Code_Count is
----------------
-- Skip_Space --
----------------
procedure Skip_Space (Line : String; Offset : in out Integer) is
begin
while Line(Offset) = ' ' or Character'Pos(Line(Offset)) = 9 loop
Offset := Offset + 1;
end loop;
end Skip_Space;
----------------------
-- Print_Core_Count --
----------------------
procedure Print_Core_Count (Count_Ident : String; Count : Integer; Number_Of_New_Lines : Ada.Text_IO.Count ) is
begin
Ada.Text_IO.Put(Count_Ident);
Ada.Integer_Text_IO.Put(Count,0);
Ada.Text_IO.New_Line(Number_Of_New_Lines);
end Print_Core_Count;
procedure Print_To_File_Info(CM: in CodeMate) is
begin
Print_Core_Count("Line Count: ", CM.Line_Count, 1);
Print_Core_Count("Code Count: ", CM.Code_Count, 1);
Print_Core_Count("Comment Count: ", CM.Comment_Count, 1);
Print_Core_Count("Null Count: ", CM.Null_Count, 1);
end Print_To_File_Info;
procedure Print_To_AllFile_Info(TM: in TotalCodeMate) is
begin
Print_Core_Count("Total Line Count: ", TM.Line_Count, 1);
Print_Core_Count("Total Code Count: ", TM.Code_Count, 1);
Print_Core_Count("Total Comment Count: ", TM.Comment_Count, 1);
Print_Core_Count("Total Null Count: ", TM.Null_Count, 1);
end Print_To_AllFile_Info;
----------
-- Read --
----------
procedure Read (FileName : String;
CM: in out CodeMate;
TM: in out TotalCodeMate) is
begin
CM := new CodeCountMate'(0,0,0,0);
TM := TCM;
Ada.Text_IO.Open(
File_Handle,
Ada.Text_IO.In_File,
FileName
);
while not Ada.Text_IO.End_Of_File(File_Handle) loop
CM.Line_Count := CM.Line_Count + 1;
declare
Line_String : String := Ada.Text_IO.Get_Line(File_Handle);
Index : Integer := 1;
begin
begin
Skip_Space(Line_String, Index);
if Line_String(Index .. Index + 1) = "--" then
CM.Comment_Count := CM.Comment_Count + 1;
else
CM.Code_Count := CM.Code_Count + 1;
end if;
exception
when Constraint_Error =>
CM.Null_Count := CM.Null_Count + 1;
end;
end;
end loop;
Ada.Text_IO.Close(File_Handle);
TM.Line_Count := TM.Line_Count + CM.Line_Count;
TM.Code_Count := TM.Code_Count + CM.Code_Count;
TM.Comment_Count := TM.Comment_Count + CM.Comment_Count;
TM.Null_Count := TM.Null_Count + CM.Null_Count;
end Read;
end Code_Count; |
programs/oeis/162/A162213.asm | neoneye/loda | 22 | 87046 | ; A162213: a(n) = the smallest positive multiple of n with exactly n digits when written in binary.
; 1,2,6,8,20,36,70,128,261,520,1034,2052,4108,8204,16395,32768,65552,131076,262162,524300,1048593,2097172,4194326,8388624,16777225,33554456,67108878,134217748,268435484,536870940,1073741854,2147483648,4294967325,8589934624,17179869210,34359738372,68719476772,137438953508,274877906979,549755813920,1099511627816,2199023255562,4398046511146,8796093022244,17592186044430,35184372088876,70368744177710,140737488355344,281474976710690,562949953421350,1125899906842671,2251799813685292,4503599627370548,9007199254741032,18014398509481990,36028797018964008,72057594037927989,144115188075855928,288230376151711802,576460752303423540,1152921504606847036,2305843009213694012,4611686018427387963,9223372036854775808,18446744073709551665,36893488147419103266,73786976294838206530,147573952589676412988,295147905179352825921,590295810358705651760,1180591620717411303494,2361183241434822606888,4722366482869645213768,9444732965739290427464,18889465931478580854825,37778931862957161709636,75557863725914323419204,151115727451828646838318,302231454903657293676622,604462909807314587353120,1208925819614629174706217,2417851639229258349412432,4835703278458516698824786,9671406556917033397649460,19342813113834066795298885,38685626227668133590597716,77371252455336267181195347,154742504910672534362390576,309485009821345068724781144,618970019642690137449562170,1237940039285380274899124251,2475880078570760549798248532,4951760157141521099596496985,9903520314283042199192993884,19807040628566084398385987625,39614081257132168796771975232,79228162514264337593543950432,158456325028528675187087900712,316912650057057350374175801385,633825300114114700748351602700
mov $1,2
pow $1,$0
add $1,$0
mov $2,$0
add $2,1
div $1,$2
mul $1,$2
mov $0,$1
|
target/cos_117/disasm/iop_overlay1/D4SKR.asm | jrrk2/cray-sim | 49 | 160462 | <gh_stars>10-100
0x0000 (0x000000) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0001 (0x000002) 0x2925- f:00024 d: 293 | OR[293] = A
0x0002 (0x000004) 0x2924- f:00024 d: 292 | OR[292] = A
0x0003 (0x000006) 0x2100- f:00020 d: 256 | A = OR[256]
0x0004 (0x000008) 0x5800- f:00054 d: 0 | B = A
0x0005 (0x00000A) 0x2104- f:00020 d: 260 | A = OR[260]
0x0006 (0x00000C) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0007 (0x00000E) 0x8635- f:00103 d: 53 | P = P + 53 (0x003C), A # 0
0x0008 (0x000010) 0x2103- f:00020 d: 259 | A = OR[259]
0x0009 (0x000012) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x000A (0x000014) 0x2908- f:00024 d: 264 | OR[264] = A
0x000B (0x000016) 0x3108- f:00030 d: 264 | A = (OR[264])
0x000C (0x000018) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x000D (0x00001A) 0x2923- f:00024 d: 291 | OR[291] = A
0x000E (0x00001C) 0x2103- f:00020 d: 259 | A = OR[259]
0x000F (0x00001E) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0010 (0x000020) 0x2908- f:00024 d: 264 | OR[264] = A
0x0011 (0x000022) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0012 (0x000024) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0013 (0x000026) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x0014 (0x000028) 0x2723- f:00023 d: 291 | A = A - OR[291]
0x0015 (0x00002A) 0x8002- f:00100 d: 2 | P = P + 2 (0x0017), C = 0
0x0016 (0x00002C) 0x8602- f:00103 d: 2 | P = P + 2 (0x0018), A # 0
0x0017 (0x00002E) 0x71C2- f:00070 d: 450 | P = P + 450 (0x01D9)
0x0018 (0x000030) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x0019 (0x000032) 0x2927- f:00024 d: 295 | OR[295] = A
0x001A (0x000034) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x001B (0x000036) 0x2928- f:00024 d: 296 | OR[296] = A
0x001C (0x000038) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x001D (0x00003A) 0x5800- f:00054 d: 0 | B = A
0x001E (0x00003C) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0020 (0x000040) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0021 (0x000042) 0x2D23- f:00026 d: 291 | OR[291] = OR[291] + 1
0x0022 (0x000044) 0x2123- f:00020 d: 291 | A = OR[291]
0x0023 (0x000046) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0024 (0x000048) 0x2923- f:00024 d: 291 | OR[291] = A
0x0025 (0x00004A) 0x2103- f:00020 d: 259 | A = OR[259]
0x0026 (0x00004C) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0027 (0x00004E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0028 (0x000050) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0029 (0x000052) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x002A (0x000054) 0x2523- f:00022 d: 291 | A = A + OR[291]
0x002B (0x000056) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x002C (0x000058) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x002D (0x00005A) 0x0400- f:00002 d: 0 | I = 0
0x002E (0x00005C) 0x0000- f:00000 d: 0 | PASS
0x002F (0x00005E) 0x102E- f:00010 d: 46 | A = 46 (0x002E)
0x0030 (0x000060) 0x29C3- f:00024 d: 451 | OR[451] = A
0x0031 (0x000062) 0x2100- f:00020 d: 256 | A = OR[256]
0x0032 (0x000064) 0x29C4- f:00024 d: 452 | OR[452] = A
0x0033 (0x000066) 0x2106- f:00020 d: 262 | A = OR[262]
0x0034 (0x000068) 0x29C5- f:00024 d: 453 | OR[453] = A
0x0035 (0x00006A) 0x2104- f:00020 d: 260 | A = OR[260]
0x0036 (0x00006C) 0x29C6- f:00024 d: 454 | OR[454] = A
0x0037 (0x00006E) 0x2107- f:00020 d: 263 | A = OR[263]
0x0038 (0x000070) 0x29C7- f:00024 d: 455 | OR[455] = A
0x0039 (0x000072) 0x2123- f:00020 d: 291 | A = OR[291]
0x003A (0x000074) 0x29C8- f:00024 d: 456 | OR[456] = A
0x003B (0x000076) 0x7DC2- f:00076 d: 450 | R = OR[450]
0x003C (0x000078) 0x2107- f:00020 d: 263 | A = OR[263]
0x003D (0x00007A) 0x1605- f:00013 d: 5 | A = A - 5 (0x0005)
0x003E (0x00007C) 0x859B- f:00102 d: 411 | P = P + 411 (0x01D9), A = 0
0x003F (0x00007E) 0x2107- f:00020 d: 263 | A = OR[263]
0x0040 (0x000080) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0041 (0x000082) 0x8598- f:00102 d: 408 | P = P + 408 (0x01D9), A = 0
0x0042 (0x000084) 0x2107- f:00020 d: 263 | A = OR[263]
0x0043 (0x000086) 0x1608- f:00013 d: 8 | A = A - 8 (0x0008)
0x0044 (0x000088) 0x8402- f:00102 d: 2 | P = P + 2 (0x0046), A = 0
0x0045 (0x00008A) 0x7025- f:00070 d: 37 | P = P + 37 (0x006A)
0x0046 (0x00008C) 0x2103- f:00020 d: 259 | A = OR[259]
0x0047 (0x00008E) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x0048 (0x000090) 0x2908- f:00024 d: 264 | OR[264] = A
0x0049 (0x000092) 0x3108- f:00030 d: 264 | A = (OR[264])
0x004A (0x000094) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x004B (0x000096) 0x2913- f:00024 d: 275 | OR[275] = A
0x004C (0x000098) 0x2103- f:00020 d: 259 | A = OR[259]
0x004D (0x00009A) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x004E (0x00009C) 0x2908- f:00024 d: 264 | OR[264] = A
0x004F (0x00009E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0050 (0x0000A0) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0051 (0x0000A2) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x0052 (0x0000A4) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x0053 (0x0000A6) 0x8002- f:00100 d: 2 | P = P + 2 (0x0055), C = 0
0x0054 (0x0000A8) 0x8602- f:00103 d: 2 | P = P + 2 (0x0056), A # 0
0x0055 (0x0000AA) 0x7184- f:00070 d: 388 | P = P + 388 (0x01D9)
0x0056 (0x0000AC) 0x2103- f:00020 d: 259 | A = OR[259]
0x0057 (0x0000AE) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x0058 (0x0000B0) 0x290D- f:00024 d: 269 | OR[269] = A
0x0059 (0x0000B2) 0x310D- f:00030 d: 269 | A = (OR[269])
0x005A (0x0000B4) 0x290E- f:00024 d: 270 | OR[270] = A
0x005B (0x0000B6) 0x210E- f:00020 d: 270 | A = OR[270]
0x005C (0x0000B8) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x005D (0x0000BA) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x005E (0x0000BC) 0x290F- f:00024 d: 271 | OR[271] = A
0x005F (0x0000BE) 0x210F- f:00020 d: 271 | A = OR[271]
0x0060 (0x0000C0) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0061 (0x0000C2) 0x290F- f:00024 d: 271 | OR[271] = A
0x0062 (0x0000C4) 0x210E- f:00020 d: 270 | A = OR[270]
0x0063 (0x0000C6) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0064 (0x0000C8) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x0065 (0x0000CA) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0066 (0x0000CC) 0x290E- f:00024 d: 270 | OR[270] = A
0x0067 (0x0000CE) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x0068 (0x0000D0) 0x210F- f:00020 d: 271 | A = OR[271]
0x0069 (0x0000D2) 0x7145- f:00070 d: 325 | P = P + 325 (0x01AE)
0x006A (0x0000D4) 0x2102- f:00020 d: 258 | A = OR[258]
0x006B (0x0000D6) 0x142A- f:00012 d: 42 | A = A + 42 (0x002A)
0x006C (0x0000D8) 0x2908- f:00024 d: 264 | OR[264] = A
0x006D (0x0000DA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x006E (0x0000DC) 0x291C- f:00024 d: 284 | OR[284] = A
0x006F (0x0000DE) 0x211C- f:00020 d: 284 | A = OR[284]
0x0070 (0x0000E0) 0x1E00-0xFFFF f:00017 d: 0 | A = A - 65535 (0xFFFF)
0x0072 (0x0000E4) 0x8408- f:00102 d: 8 | P = P + 8 (0x007A), A = 0
0x0073 (0x0000E6) 0x211C- f:00020 d: 284 | A = OR[284]
0x0074 (0x0000E8) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0075 (0x0000EA) 0x2908- f:00024 d: 264 | OR[264] = A
0x0076 (0x0000EC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0077 (0x0000EE) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0078 (0x0000F0) 0x8402- f:00102 d: 2 | P = P + 2 (0x007A), A = 0
0x0079 (0x0000F2) 0x703E- f:00070 d: 62 | P = P + 62 (0x00B7)
0x007A (0x0000F4) 0x2103- f:00020 d: 259 | A = OR[259]
0x007B (0x0000F6) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x007C (0x0000F8) 0x2908- f:00024 d: 264 | OR[264] = A
0x007D (0x0000FA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x007E (0x0000FC) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x007F (0x0000FE) 0x2913- f:00024 d: 275 | OR[275] = A
0x0080 (0x000100) 0x2103- f:00020 d: 259 | A = OR[259]
0x0081 (0x000102) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0082 (0x000104) 0x2908- f:00024 d: 264 | OR[264] = A
0x0083 (0x000106) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0084 (0x000108) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0085 (0x00010A) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x0086 (0x00010C) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x0087 (0x00010E) 0x8002- f:00100 d: 2 | P = P + 2 (0x0089), C = 0
0x0088 (0x000110) 0x8602- f:00103 d: 2 | P = P + 2 (0x008A), A # 0
0x0089 (0x000112) 0x7150- f:00070 d: 336 | P = P + 336 (0x01D9)
0x008A (0x000114) 0x2103- f:00020 d: 259 | A = OR[259]
0x008B (0x000116) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x008C (0x000118) 0x290D- f:00024 d: 269 | OR[269] = A
0x008D (0x00011A) 0x310D- f:00030 d: 269 | A = (OR[269])
0x008E (0x00011C) 0x290E- f:00024 d: 270 | OR[270] = A
0x008F (0x00011E) 0x210E- f:00020 d: 270 | A = OR[270]
0x0090 (0x000120) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0091 (0x000122) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0092 (0x000124) 0x290F- f:00024 d: 271 | OR[271] = A
0x0093 (0x000126) 0x210F- f:00020 d: 271 | A = OR[271]
0x0094 (0x000128) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0095 (0x00012A) 0x290F- f:00024 d: 271 | OR[271] = A
0x0096 (0x00012C) 0x210E- f:00020 d: 270 | A = OR[270]
0x0097 (0x00012E) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0098 (0x000130) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x0099 (0x000132) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x009A (0x000134) 0x290E- f:00024 d: 270 | OR[270] = A
0x009B (0x000136) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x009C (0x000138) 0x210F- f:00020 d: 271 | A = OR[271]
0x009D (0x00013A) 0x7E03-0x0301 f:00077 d: 3 | R = OR[3]+769 (0x0301)
0x009F (0x00013E) 0x2107- f:00020 d: 263 | A = OR[263]
0x00A0 (0x000140) 0x8739- f:00103 d: 313 | P = P + 313 (0x01D9), A # 0
0x00A1 (0x000142) 0x1800-0x0800 f:00014 d: 0 | A = 2048 (0x0800)
0x00A3 (0x000146) 0x2906- f:00024 d: 262 | OR[262] = A
0x00A4 (0x000148) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00A5 (0x00014A) 0xFE00- f:00177 d: 0 | IOB , fn017
0x00A6 (0x00014C) 0x7E03-0x02E6 f:00077 d: 3 | R = OR[3]+742 (0x02E6)
0x00A8 (0x000150) 0x8402- f:00102 d: 2 | P = P + 2 (0x00AA), A = 0
0x00A9 (0x000152) 0x7005- f:00070 d: 5 | P = P + 5 (0x00AE)
0x00AA (0x000154) 0x1800-0xFFFF f:00014 d: 0 | A = 65535 (0xFFFF)
0x00AC (0x000158) 0x291C- f:00024 d: 284 | OR[284] = A
0x00AD (0x00015A) 0x7003- f:00070 d: 3 | P = P + 3 (0x00B0)
0x00AE (0x00015C) 0xF400- f:00172 d: 0 | IOB , fn012
0x00AF (0x00015E) 0x291C- f:00024 d: 284 | OR[284] = A
0x00B0 (0x000160) 0x2102- f:00020 d: 258 | A = OR[258]
0x00B1 (0x000162) 0x142A- f:00012 d: 42 | A = A + 42 (0x002A)
0x00B2 (0x000164) 0x2908- f:00024 d: 264 | OR[264] = A
0x00B3 (0x000166) 0x211C- f:00020 d: 284 | A = OR[284]
0x00B4 (0x000168) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00B5 (0x00016A) 0x72AD- f:00071 d: 173 | P = P - 173 (0x0008)
0x00B6 (0x00016C) 0x702C- f:00070 d: 44 | P = P + 44 (0x00E2)
0x00B7 (0x00016E) 0x211C- f:00020 d: 284 | A = OR[284]
0x00B8 (0x000170) 0x1270- f:00011 d: 112 | A = A & 112 (0x0070)
0x00B9 (0x000172) 0x2908- f:00024 d: 264 | OR[264] = A
0x00BA (0x000174) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00BB (0x000176) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x00BC (0x000178) 0x8602- f:00103 d: 2 | P = P + 2 (0x00BE), A # 0
0x00BD (0x00017A) 0x7025- f:00070 d: 37 | P = P + 37 (0x00E2)
0x00BE (0x00017C) 0x2103- f:00020 d: 259 | A = OR[259]
0x00BF (0x00017E) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x00C0 (0x000180) 0x2908- f:00024 d: 264 | OR[264] = A
0x00C1 (0x000182) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00C2 (0x000184) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x00C3 (0x000186) 0x2913- f:00024 d: 275 | OR[275] = A
0x00C4 (0x000188) 0x2103- f:00020 d: 259 | A = OR[259]
0x00C5 (0x00018A) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x00C6 (0x00018C) 0x2908- f:00024 d: 264 | OR[264] = A
0x00C7 (0x00018E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00C8 (0x000190) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x00C9 (0x000192) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x00CA (0x000194) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x00CB (0x000196) 0x8002- f:00100 d: 2 | P = P + 2 (0x00CD), C = 0
0x00CC (0x000198) 0x8602- f:00103 d: 2 | P = P + 2 (0x00CE), A # 0
0x00CD (0x00019A) 0x710C- f:00070 d: 268 | P = P + 268 (0x01D9)
0x00CE (0x00019C) 0x2103- f:00020 d: 259 | A = OR[259]
0x00CF (0x00019E) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x00D0 (0x0001A0) 0x290D- f:00024 d: 269 | OR[269] = A
0x00D1 (0x0001A2) 0x310D- f:00030 d: 269 | A = (OR[269])
0x00D2 (0x0001A4) 0x290E- f:00024 d: 270 | OR[270] = A
0x00D3 (0x0001A6) 0x210E- f:00020 d: 270 | A = OR[270]
0x00D4 (0x0001A8) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x00D5 (0x0001AA) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x00D6 (0x0001AC) 0x290F- f:00024 d: 271 | OR[271] = A
0x00D7 (0x0001AE) 0x210F- f:00020 d: 271 | A = OR[271]
0x00D8 (0x0001B0) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x00D9 (0x0001B2) 0x290F- f:00024 d: 271 | OR[271] = A
0x00DA (0x0001B4) 0x210E- f:00020 d: 270 | A = OR[270]
0x00DB (0x0001B6) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x00DC (0x0001B8) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x00DD (0x0001BA) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x00DE (0x0001BC) 0x290E- f:00024 d: 270 | OR[270] = A
0x00DF (0x0001BE) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x00E0 (0x0001C0) 0x210F- f:00020 d: 271 | A = OR[271]
0x00E1 (0x0001C2) 0x70CD- f:00070 d: 205 | P = P + 205 (0x01AE)
0x00E2 (0x0001C4) 0x2102- f:00020 d: 258 | A = OR[258]
0x00E3 (0x0001C6) 0x142B- f:00012 d: 43 | A = A + 43 (0x002B)
0x00E4 (0x0001C8) 0x2908- f:00024 d: 264 | OR[264] = A
0x00E5 (0x0001CA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00E6 (0x0001CC) 0x291D- f:00024 d: 285 | OR[285] = A
0x00E7 (0x0001CE) 0x211D- f:00020 d: 285 | A = OR[285]
0x00E8 (0x0001D0) 0x1A00-0x2000 f:00015 d: 0 | A = A & 8192 (0x2000)
0x00EA (0x0001D4) 0x2908- f:00024 d: 264 | OR[264] = A
0x00EB (0x0001D6) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00EC (0x0001D8) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x00ED (0x0001DA) 0x8602- f:00103 d: 2 | P = P + 2 (0x00EF), A # 0
0x00EE (0x0001DC) 0x702E- f:00070 d: 46 | P = P + 46 (0x011C)
0x00EF (0x0001DE) 0x2103- f:00020 d: 259 | A = OR[259]
0x00F0 (0x0001E0) 0x1406- f:00012 d: 6 | A = A + 6 (0x0006)
0x00F1 (0x0001E2) 0x2908- f:00024 d: 264 | OR[264] = A
0x00F2 (0x0001E4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00F3 (0x0001E6) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x00F4 (0x0001E8) 0x2913- f:00024 d: 275 | OR[275] = A
0x00F5 (0x0001EA) 0x2103- f:00020 d: 259 | A = OR[259]
0x00F6 (0x0001EC) 0x1406- f:00012 d: 6 | A = A + 6 (0x0006)
0x00F7 (0x0001EE) 0x2908- f:00024 d: 264 | OR[264] = A
0x00F8 (0x0001F0) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00F9 (0x0001F2) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x00FA (0x0001F4) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x00FB (0x0001F6) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x00FC (0x0001F8) 0x8002- f:00100 d: 2 | P = P + 2 (0x00FE), C = 0
0x00FD (0x0001FA) 0x8602- f:00103 d: 2 | P = P + 2 (0x00FF), A # 0
0x00FE (0x0001FC) 0x70DB- f:00070 d: 219 | P = P + 219 (0x01D9)
0x00FF (0x0001FE) 0x2103- f:00020 d: 259 | A = OR[259]
0x0100 (0x000200) 0x1406- f:00012 d: 6 | A = A + 6 (0x0006)
0x0101 (0x000202) 0x290D- f:00024 d: 269 | OR[269] = A
0x0102 (0x000204) 0x310D- f:00030 d: 269 | A = (OR[269])
0x0103 (0x000206) 0x290E- f:00024 d: 270 | OR[270] = A
0x0104 (0x000208) 0x210E- f:00020 d: 270 | A = OR[270]
0x0105 (0x00020A) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0106 (0x00020C) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0107 (0x00020E) 0x290F- f:00024 d: 271 | OR[271] = A
0x0108 (0x000210) 0x210F- f:00020 d: 271 | A = OR[271]
0x0109 (0x000212) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x010A (0x000214) 0x290F- f:00024 d: 271 | OR[271] = A
0x010B (0x000216) 0x210E- f:00020 d: 270 | A = OR[270]
0x010C (0x000218) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x010D (0x00021A) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x010E (0x00021C) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x010F (0x00021E) 0x290E- f:00024 d: 270 | OR[270] = A
0x0110 (0x000220) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x0111 (0x000222) 0x210F- f:00020 d: 271 | A = OR[271]
0x0112 (0x000224) 0x7E03-0x028A f:00077 d: 3 | R = OR[3]+650 (0x028A)
0x0114 (0x000228) 0x211D- f:00020 d: 285 | A = OR[285]
0x0115 (0x00022A) 0x1A00-0x2000 f:00015 d: 0 | A = A & 8192 (0x2000)
0x0117 (0x00022E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0118 (0x000230) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0119 (0x000232) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x011A (0x000234) 0x8F12- f:00107 d: 274 | P = P - 274 (0x0008), A # 0
0x011B (0x000236) 0x7093- f:00070 d: 147 | P = P + 147 (0x01AE)
0x011C (0x000238) 0x211D- f:00020 d: 285 | A = OR[285]
0x011D (0x00023A) 0x1A00-0x1813 f:00015 d: 0 | A = A & 6163 (0x1813)
0x011F (0x00023E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0120 (0x000240) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0121 (0x000242) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0122 (0x000244) 0x8602- f:00103 d: 2 | P = P + 2 (0x0124), A # 0
0x0123 (0x000246) 0x7029- f:00070 d: 41 | P = P + 41 (0x014C)
0x0124 (0x000248) 0x2103- f:00020 d: 259 | A = OR[259]
0x0125 (0x00024A) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x0126 (0x00024C) 0x2908- f:00024 d: 264 | OR[264] = A
0x0127 (0x00024E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0128 (0x000250) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0129 (0x000252) 0x2913- f:00024 d: 275 | OR[275] = A
0x012A (0x000254) 0x2103- f:00020 d: 259 | A = OR[259]
0x012B (0x000256) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x012C (0x000258) 0x2908- f:00024 d: 264 | OR[264] = A
0x012D (0x00025A) 0x3108- f:00030 d: 264 | A = (OR[264])
0x012E (0x00025C) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x012F (0x00025E) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x0130 (0x000260) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x0131 (0x000262) 0x8002- f:00100 d: 2 | P = P + 2 (0x0133), C = 0
0x0132 (0x000264) 0x8602- f:00103 d: 2 | P = P + 2 (0x0134), A # 0
0x0133 (0x000266) 0x70A6- f:00070 d: 166 | P = P + 166 (0x01D9)
0x0134 (0x000268) 0x2103- f:00020 d: 259 | A = OR[259]
0x0135 (0x00026A) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x0136 (0x00026C) 0x290D- f:00024 d: 269 | OR[269] = A
0x0137 (0x00026E) 0x310D- f:00030 d: 269 | A = (OR[269])
0x0138 (0x000270) 0x290E- f:00024 d: 270 | OR[270] = A
0x0139 (0x000272) 0x210E- f:00020 d: 270 | A = OR[270]
0x013A (0x000274) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x013B (0x000276) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x013C (0x000278) 0x290F- f:00024 d: 271 | OR[271] = A
0x013D (0x00027A) 0x210F- f:00020 d: 271 | A = OR[271]
0x013E (0x00027C) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x013F (0x00027E) 0x290F- f:00024 d: 271 | OR[271] = A
0x0140 (0x000280) 0x210E- f:00020 d: 270 | A = OR[270]
0x0141 (0x000282) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0142 (0x000284) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x0143 (0x000286) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0144 (0x000288) 0x290E- f:00024 d: 270 | OR[270] = A
0x0145 (0x00028A) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x0146 (0x00028C) 0x210F- f:00020 d: 271 | A = OR[271]
0x0147 (0x00028E) 0x7E03-0x02EF f:00077 d: 3 | R = OR[3]+751 (0x02EF)
0x0149 (0x000292) 0x2105- f:00020 d: 261 | A = OR[261]
0x014A (0x000294) 0x160D- f:00013 d: 13 | A = A - 13 (0x000D)
0x014B (0x000296) 0x8477- f:00102 d: 119 | P = P + 119 (0x01C2), A = 0
0x014C (0x000298) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x014D (0x00029A) 0x291E- f:00024 d: 286 | OR[286] = A
0x014E (0x00029C) 0x7E03-0x027B f:00077 d: 3 | R = OR[3]+635 (0x027B)
0x0150 (0x0002A0) 0x211F- f:00020 d: 287 | A = OR[287]
0x0151 (0x0002A2) 0x1E00-0xFFFF f:00017 d: 0 | A = A - 65535 (0xFFFF)
0x0153 (0x0002A6) 0x8437- f:00102 d: 55 | P = P + 55 (0x018A), A = 0
0x0154 (0x0002A8) 0x211F- f:00020 d: 287 | A = OR[287]
0x0155 (0x0002AA) 0x1A00-0xF9C9 f:00015 d: 0 | A = A & 63945 (0xF9C9)
0x0157 (0x0002AE) 0x2913- f:00024 d: 275 | OR[275] = A
0x0158 (0x0002B0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0159 (0x0002B2) 0x291E- f:00024 d: 286 | OR[286] = A
0x015A (0x0002B4) 0x2113- f:00020 d: 275 | A = OR[275]
0x015B (0x0002B6) 0x0A01- f:00005 d: 1 | A = A < 1 (0x0001)
0x015C (0x0002B8) 0x2913- f:00024 d: 275 | OR[275] = A
0x015D (0x0002BA) 0x808C- f:00100 d: 140 | P = P + 140 (0x01E9), C = 0
0x015E (0x0002BC) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x015F (0x0002BE) 0x291E- f:00024 d: 286 | OR[286] = A
0x0160 (0x0002C0) 0x2113- f:00020 d: 275 | A = OR[275]
0x0161 (0x0002C2) 0x0A01- f:00005 d: 1 | A = A < 1 (0x0001)
0x0162 (0x0002C4) 0x2913- f:00024 d: 275 | OR[275] = A
0x0163 (0x0002C6) 0x8086- f:00100 d: 134 | P = P + 134 (0x01E9), C = 0
0x0164 (0x0002C8) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x0165 (0x0002CA) 0x291E- f:00024 d: 286 | OR[286] = A
0x0166 (0x0002CC) 0x2113- f:00020 d: 275 | A = OR[275]
0x0167 (0x0002CE) 0x0A07- f:00005 d: 7 | A = A < 7 (0x0007)
0x0168 (0x0002D0) 0x2913- f:00024 d: 275 | OR[275] = A
0x0169 (0x0002D2) 0x8280- f:00101 d: 128 | P = P + 128 (0x01E9), C = 1
0x016A (0x0002D4) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x016B (0x0002D6) 0x291E- f:00024 d: 286 | OR[286] = A
0x016C (0x0002D8) 0x2113- f:00020 d: 275 | A = OR[275]
0x016D (0x0002DA) 0x0A01- f:00005 d: 1 | A = A < 1 (0x0001)
0x016E (0x0002DC) 0x2913- f:00024 d: 275 | OR[275] = A
0x016F (0x0002DE) 0x807A- f:00100 d: 122 | P = P + 122 (0x01E9), C = 0
0x0170 (0x0002E0) 0x1004- f:00010 d: 4 | A = 4 (0x0004)
0x0171 (0x0002E2) 0x291E- f:00024 d: 286 | OR[286] = A
0x0172 (0x0002E4) 0x2113- f:00020 d: 275 | A = OR[275]
0x0173 (0x0002E6) 0x0A03- f:00005 d: 3 | A = A < 3 (0x0003)
0x0174 (0x0002E8) 0x2913- f:00024 d: 275 | OR[275] = A
0x0175 (0x0002EA) 0x8074- f:00100 d: 116 | P = P + 116 (0x01E9), C = 0
0x0176 (0x0002EC) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0177 (0x0002EE) 0x291E- f:00024 d: 286 | OR[286] = A
0x0178 (0x0002F0) 0x2113- f:00020 d: 275 | A = OR[275]
0x0179 (0x0002F2) 0x0A03- f:00005 d: 3 | A = A < 3 (0x0003)
0x017A (0x0002F4) 0x2913- f:00024 d: 275 | OR[275] = A
0x017B (0x0002F6) 0x806E- f:00100 d: 110 | P = P + 110 (0x01E9), C = 0
0x017C (0x0002F8) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x017D (0x0002FA) 0x291E- f:00024 d: 286 | OR[286] = A
0x017E (0x0002FC) 0x7E03-0x027B f:00077 d: 3 | R = OR[3]+635 (0x027B)
0x0180 (0x000300) 0x211F- f:00020 d: 287 | A = OR[287]
0x0181 (0x000302) 0x1E00-0xFFFF f:00017 d: 0 | A = A - 65535 (0xFFFF)
0x0183 (0x000306) 0x8407- f:00102 d: 7 | P = P + 7 (0x018A), A = 0
0x0184 (0x000308) 0x1006- f:00010 d: 6 | A = 6 (0x0006)
0x0185 (0x00030A) 0x291E- f:00024 d: 286 | OR[286] = A
0x0186 (0x00030C) 0x211F- f:00020 d: 287 | A = OR[287]
0x0187 (0x00030E) 0x0A01- f:00005 d: 1 | A = A < 1 (0x0001)
0x0188 (0x000310) 0x2913- f:00024 d: 275 | OR[275] = A
0x0189 (0x000312) 0x8260- f:00101 d: 96 | P = P + 96 (0x01E9), C = 1
0x018A (0x000314) 0x2103- f:00020 d: 259 | A = OR[259]
0x018B (0x000316) 0x140A- f:00012 d: 10 | A = A + 10 (0x000A)
0x018C (0x000318) 0x2908- f:00024 d: 264 | OR[264] = A
0x018D (0x00031A) 0x3108- f:00030 d: 264 | A = (OR[264])
0x018E (0x00031C) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x018F (0x00031E) 0x2913- f:00024 d: 275 | OR[275] = A
0x0190 (0x000320) 0x2103- f:00020 d: 259 | A = OR[259]
0x0191 (0x000322) 0x140A- f:00012 d: 10 | A = A + 10 (0x000A)
0x0192 (0x000324) 0x2908- f:00024 d: 264 | OR[264] = A
0x0193 (0x000326) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0194 (0x000328) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0195 (0x00032A) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x0196 (0x00032C) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x0197 (0x00032E) 0x8002- f:00100 d: 2 | P = P + 2 (0x0199), C = 0
0x0198 (0x000330) 0x8603- f:00103 d: 3 | P = P + 3 (0x019B), A # 0
0x0199 (0x000332) 0x7A03-0x0229 f:00075 d: 3 | P = OR[3]+553 (0x0229)
0x019B (0x000336) 0x2103- f:00020 d: 259 | A = OR[259]
0x019C (0x000338) 0x140A- f:00012 d: 10 | A = A + 10 (0x000A)
0x019D (0x00033A) 0x290D- f:00024 d: 269 | OR[269] = A
0x019E (0x00033C) 0x310D- f:00030 d: 269 | A = (OR[269])
0x019F (0x00033E) 0x290E- f:00024 d: 270 | OR[270] = A
0x01A0 (0x000340) 0x210E- f:00020 d: 270 | A = OR[270]
0x01A1 (0x000342) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x01A2 (0x000344) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x01A3 (0x000346) 0x290F- f:00024 d: 271 | OR[271] = A
0x01A4 (0x000348) 0x210F- f:00020 d: 271 | A = OR[271]
0x01A5 (0x00034A) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x01A6 (0x00034C) 0x290F- f:00024 d: 271 | OR[271] = A
0x01A7 (0x00034E) 0x210E- f:00020 d: 270 | A = OR[270]
0x01A8 (0x000350) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x01A9 (0x000352) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x01AA (0x000354) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x01AB (0x000356) 0x290E- f:00024 d: 270 | OR[270] = A
0x01AC (0x000358) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x01AD (0x00035A) 0x210F- f:00020 d: 271 | A = OR[271]
0x01AE (0x00035C) 0x7E03-0x02F2 f:00077 d: 3 | R = OR[3]+754 (0x02F2)
0x01B0 (0x000360) 0x2105- f:00020 d: 261 | A = OR[261]
0x01B1 (0x000362) 0x160D- f:00013 d: 13 | A = A - 13 (0x000D)
0x01B2 (0x000364) 0x8410- f:00102 d: 16 | P = P + 16 (0x01C2), A = 0
0x01B3 (0x000366) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01B4 (0x000368) 0x2926- f:00024 d: 294 | OR[294] = A
0x01B5 (0x00036A) 0x7E03-0x0254 f:00077 d: 3 | R = OR[3]+596 (0x0254)
0x01B7 (0x00036E) 0x2107- f:00020 d: 263 | A = OR[263]
0x01B8 (0x000370) 0x862E- f:00103 d: 46 | P = P + 46 (0x01E6), A # 0
0x01B9 (0x000372) 0x211B- f:00020 d: 283 | A = OR[283]
0x01BA (0x000374) 0x8602- f:00103 d: 2 | P = P + 2 (0x01BC), A # 0
0x01BB (0x000376) 0x7007- f:00070 d: 7 | P = P + 7 (0x01C2)
0x01BC (0x000378) 0x211B- f:00020 d: 283 | A = OR[283]
0x01BD (0x00037A) 0x2926- f:00024 d: 294 | OR[294] = A
0x01BE (0x00037C) 0x7E03-0x0254 f:00077 d: 3 | R = OR[3]+596 (0x0254)
0x01C0 (0x000380) 0x2107- f:00020 d: 263 | A = OR[263]
0x01C1 (0x000382) 0x8625- f:00103 d: 37 | P = P + 37 (0x01E6), A # 0
0x01C2 (0x000384) 0x2125- f:00020 d: 293 | A = OR[293]
0x01C3 (0x000386) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x01C4 (0x000388) 0x2925- f:00024 d: 293 | OR[293] = A
0x01C5 (0x00038A) 0x2102- f:00020 d: 258 | A = OR[258]
0x01C6 (0x00038C) 0x141F- f:00012 d: 31 | A = A + 31 (0x001F)
0x01C7 (0x00038E) 0x2908- f:00024 d: 264 | OR[264] = A
0x01C8 (0x000390) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01C9 (0x000392) 0x0E0F- f:00007 d: 15 | A = A << 15 (0x000F)
0x01CA (0x000394) 0x0A01- f:00005 d: 1 | A = A < 1 (0x0001)
0x01CB (0x000396) 0x2525- f:00022 d: 293 | A = A + OR[293]
0x01CC (0x000398) 0x0C10- f:00006 d: 16 | A = A >> 16 (0x0010)
0x01CD (0x00039A) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01CE (0x00039C) 0x2102- f:00020 d: 258 | A = OR[258]
0x01CF (0x00039E) 0x142F- f:00012 d: 47 | A = A + 47 (0x002F)
0x01D0 (0x0003A0) 0x2908- f:00024 d: 264 | OR[264] = A
0x01D1 (0x0003A2) 0x2124- f:00020 d: 292 | A = OR[292]
0x01D2 (0x0003A4) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01D3 (0x0003A6) 0x102A- f:00010 d: 42 | A = 42 (0x002A)
0x01D4 (0x0003A8) 0x2927- f:00024 d: 295 | OR[295] = A
0x01D5 (0x0003AA) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x01D6 (0x0003AC) 0x5800- f:00054 d: 0 | B = A
0x01D7 (0x0003AE) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01D8 (0x0003B0) 0x7C09- f:00076 d: 9 | R = OR[9]
0x01D9 (0x0003B2) 0x2102- f:00020 d: 258 | A = OR[258]
0x01DA (0x0003B4) 0x142C- f:00012 d: 44 | A = A + 44 (0x002C)
0x01DB (0x0003B6) 0x2908- f:00024 d: 264 | OR[264] = A
0x01DC (0x0003B8) 0x2106- f:00020 d: 262 | A = OR[262]
0x01DD (0x0003BA) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01DE (0x0003BC) 0x2102- f:00020 d: 258 | A = OR[258]
0x01DF (0x0003BE) 0x142E- f:00012 d: 46 | A = A + 46 (0x002E)
0x01E0 (0x0003C0) 0x2908- f:00024 d: 264 | OR[264] = A
0x01E1 (0x0003C2) 0x2107- f:00020 d: 263 | A = OR[263]
0x01E2 (0x0003C4) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01E3 (0x0003C6) 0x100D- f:00010 d: 13 | A = 13 (0x000D)
0x01E4 (0x0003C8) 0x2905- f:00024 d: 261 | OR[261] = A
0x01E5 (0x0003CA) 0x7223- f:00071 d: 35 | P = P - 35 (0x01C2)
0x01E6 (0x0003CC) 0x7E03-0x028A f:00077 d: 3 | R = OR[3]+650 (0x028A)
0x01E8 (0x0003D0) 0x73E0- f:00071 d: 480 | P = P - 480 (0x0008)
0x01E9 (0x0003D2) 0x2103- f:00020 d: 259 | A = OR[259]
0x01EA (0x0003D4) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x01EB (0x0003D6) 0x2908- f:00024 d: 264 | OR[264] = A
0x01EC (0x0003D8) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01ED (0x0003DA) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x01EE (0x0003DC) 0x2913- f:00024 d: 275 | OR[275] = A
0x01EF (0x0003DE) 0x2103- f:00020 d: 259 | A = OR[259]
0x01F0 (0x0003E0) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x01F1 (0x0003E2) 0x2908- f:00024 d: 264 | OR[264] = A
0x01F2 (0x0003E4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01F3 (0x0003E6) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x01F4 (0x0003E8) 0x4200- f:00041 d: 0 | C = 1, io 0000 (IOR) = BZ
0x01F5 (0x0003EA) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x01F6 (0x0003EC) 0x8002- f:00100 d: 2 | P = P + 2 (0x01F8), C = 0
0x01F7 (0x0003EE) 0x8602- f:00103 d: 2 | P = P + 2 (0x01F9), A # 0
0x01F8 (0x0003F0) 0x721F- f:00071 d: 31 | P = P - 31 (0x01D9)
0x01F9 (0x0003F2) 0x2103- f:00020 d: 259 | A = OR[259]
0x01FA (0x0003F4) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x01FB (0x0003F6) 0x290D- f:00024 d: 269 | OR[269] = A
0x01FC (0x0003F8) 0x310D- f:00030 d: 269 | A = (OR[269])
0x01FD (0x0003FA) 0x290E- f:00024 d: 270 | OR[270] = A
0x01FE (0x0003FC) 0x210E- f:00020 d: 270 | A = OR[270]
0x01FF (0x0003FE) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0200 (0x000400) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0201 (0x000402) 0x290F- f:00024 d: 271 | OR[271] = A
0x0202 (0x000404) 0x210F- f:00020 d: 271 | A = OR[271]
0x0203 (0x000406) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0204 (0x000408) 0x290F- f:00024 d: 271 | OR[271] = A
0x0205 (0x00040A) 0x210E- f:00020 d: 270 | A = OR[270]
0x0206 (0x00040C) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0207 (0x00040E) 0x250F- f:00022 d: 271 | A = A + OR[271]
0x0208 (0x000410) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0209 (0x000412) 0x290E- f:00024 d: 270 | OR[270] = A
0x020A (0x000414) 0x390D- f:00034 d: 269 | (OR[269]) = A
0x020B (0x000416) 0x210F- f:00020 d: 271 | A = OR[271]
0x020C (0x000418) 0x74DD- f:00072 d: 221 | R = P + 221 (0x02E9)
0x020D (0x00041A) 0x2105- f:00020 d: 261 | A = OR[261]
0x020E (0x00041C) 0x160D- f:00013 d: 13 | A = A - 13 (0x000D)
0x020F (0x00041E) 0x8C4D- f:00106 d: 77 | P = P - 77 (0x01C2), A = 0
0x0210 (0x000420) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0211 (0x000422) 0x2927- f:00024 d: 295 | OR[295] = A
0x0212 (0x000424) 0x1800-0x0057 f:00014 d: 0 | A = 87 (0x0057)
0x0214 (0x000428) 0x2928- f:00024 d: 296 | OR[296] = A
0x0215 (0x00042A) 0x211E- f:00020 d: 286 | A = OR[286]
0x0216 (0x00042C) 0x2929- f:00024 d: 297 | OR[297] = A
0x0217 (0x00042E) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x0218 (0x000430) 0x292A- f:00024 d: 298 | OR[298] = A
0x0219 (0x000432) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x021A (0x000434) 0x5800- f:00054 d: 0 | B = A
0x021B (0x000436) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x021D (0x00043A) 0x7C09- f:00076 d: 9 | R = OR[9]
0x021E (0x00043C) 0x211F- f:00020 d: 287 | A = OR[287]
0x021F (0x00043E) 0x1659- f:00013 d: 89 | A = A - 89 (0x0059)
0x0220 (0x000440) 0xAC03-0x000E f:00126 d: 3 | P = OR[3]+14 (0x000E), A = 0
0x0222 (0x000444) 0x7249- f:00071 d: 73 | P = P - 73 (0x01D9)
0x0223 (0x000446) 0x2125- f:00020 d: 293 | A = OR[293]
0x0224 (0x000448) 0x8E4B- f:00107 d: 75 | P = P - 75 (0x01D9), A # 0
0x0225 (0x00044A) 0x74D6- f:00072 d: 214 | R = P + 214 (0x02FB)
0x0226 (0x00044C) 0x2107- f:00020 d: 263 | A = OR[263]
0x0227 (0x00044E) 0x8E4E- f:00107 d: 78 | P = P - 78 (0x01D9), A # 0
0x0228 (0x000450) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0229 (0x000452) 0x2925- f:00024 d: 293 | OR[293] = A
0x022A (0x000454) 0x1800-0x1000 f:00014 d: 0 | A = 4096 (0x1000)
0x022C (0x000458) 0x2906- f:00024 d: 262 | OR[262] = A
0x022D (0x00045A) 0x1800-0x0803 f:00014 d: 0 | A = 2051 (0x0803)
0x022F (0x00045E) 0x2920- f:00024 d: 288 | OR[288] = A
0x0230 (0x000460) 0x1C00-0x9000 f:00016 d: 0 | A = A + 36864 (0x9000)
0x0232 (0x000464) 0xE200- f:00161 d: 0 | IOB , fn001
0x0233 (0x000466) 0x101E- f:00010 d: 30 | A = 30 (0x001E)
0x0234 (0x000468) 0x2922- f:00024 d: 290 | OR[290] = A
0x0235 (0x00046A) 0x7464- f:00072 d: 100 | R = P + 100 (0x0299)
0x0236 (0x00046C) 0x2107- f:00020 d: 263 | A = OR[263]
0x0237 (0x00046E) 0x8E5E- f:00107 d: 94 | P = P - 94 (0x01D9), A # 0
0x0238 (0x000470) 0x211C- f:00020 d: 284 | A = OR[284]
0x0239 (0x000472) 0x1E00-0x0301 f:00017 d: 0 | A = A - 769 (0x0301)
0x023B (0x000476) 0x8E62- f:00107 d: 98 | P = P - 98 (0x01D9), A # 0
0x023C (0x000478) 0x211D- f:00020 d: 285 | A = OR[285]
0x023D (0x00047A) 0x2720- f:00023 d: 288 | A = A - OR[288]
0x023E (0x00047C) 0x8E65- f:00107 d: 101 | P = P - 101 (0x01D9), A # 0
0x023F (0x00047E) 0x100F- f:00010 d: 15 | A = 15 (0x000F)
0x0240 (0x000480) 0x291E- f:00024 d: 286 | OR[286] = A
0x0241 (0x000482) 0x7434- f:00072 d: 52 | R = P + 52 (0x0275)
0x0242 (0x000484) 0x211F- f:00020 d: 287 | A = OR[287]
0x0243 (0x000486) 0x2924- f:00024 d: 292 | OR[292] = A
0x0244 (0x000488) 0x1E00-0xFFFF f:00017 d: 0 | A = A - 65535 (0xFFFF)
0x0246 (0x00048C) 0x8C6D- f:00106 d: 109 | P = P - 109 (0x01D9), A = 0
0x0247 (0x00048E) 0x2124- f:00020 d: 292 | A = OR[292]
0x0248 (0x000490) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0249 (0x000492) 0x2908- f:00024 d: 264 | OR[264] = A
0x024A (0x000494) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x024B (0x000496) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x024C (0x000498) 0x8E73- f:00107 d: 115 | P = P - 115 (0x01D9), A # 0
0x024D (0x00049A) 0x769F- f:00073 d: 159 | R = P - 159 (0x01AE)
0x024E (0x00049C) 0x74AD- f:00072 d: 173 | R = P + 173 (0x02FB)
0x024F (0x00049E) 0x2107- f:00020 d: 263 | A = OR[263]
0x0250 (0x0004A0) 0x8402- f:00102 d: 2 | P = P + 2 (0x0252), A = 0
0x0251 (0x0004A2) 0x0200- f:00001 d: 0 | EXIT
0x0252 (0x0004A4) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x0253 (0x0004A6) 0x2906- f:00024 d: 262 | OR[262] = A
0x0254 (0x0004A8) 0x2118- f:00020 d: 280 | A = OR[280]
0x0255 (0x0004AA) 0x2526- f:00022 d: 294 | A = A + OR[294]
0x0256 (0x0004AC) 0x2920- f:00024 d: 288 | OR[288] = A
0x0257 (0x0004AE) 0xEA00- f:00165 d: 0 | IOB , fn005
0x0258 (0x0004B0) 0x2101- f:00020 d: 257 | A = OR[257]
0x0259 (0x0004B2) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x025A (0x0004B4) 0x2908- f:00024 d: 264 | OR[264] = A
0x025B (0x0004B6) 0x2118- f:00020 d: 280 | A = OR[280]
0x025C (0x0004B8) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x025D (0x0004BA) 0x1014- f:00010 d: 20 | A = 20 (0x0014)
0x025E (0x0004BC) 0x2922- f:00024 d: 290 | OR[290] = A
0x025F (0x0004BE) 0x743A- f:00072 d: 58 | R = P + 58 (0x0299)
0x0260 (0x0004C0) 0x2107- f:00020 d: 263 | A = OR[263]
0x0261 (0x0004C2) 0x8402- f:00102 d: 2 | P = P + 2 (0x0263), A = 0
0x0262 (0x0004C4) 0x0200- f:00001 d: 0 | EXIT
0x0263 (0x0004C6) 0x2120- f:00020 d: 288 | A = OR[288]
0x0264 (0x0004C8) 0x0A08- f:00005 d: 8 | A = A < 8 (0x0008)
0x0265 (0x0004CA) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0266 (0x0004CC) 0x2908- f:00024 d: 264 | OR[264] = A
0x0267 (0x0004CE) 0x211C- f:00020 d: 284 | A = OR[284]
0x0268 (0x0004D0) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0269 (0x0004D2) 0x8602- f:00103 d: 2 | P = P + 2 (0x026B), A # 0
0x026A (0x0004D4) 0x7004- f:00070 d: 4 | P = P + 4 (0x026E)
0x026B (0x0004D6) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x026C (0x0004D8) 0x2907- f:00024 d: 263 | OR[263] = A
0x026D (0x0004DA) 0x7007- f:00070 d: 7 | P = P + 7 (0x0274)
0x026E (0x0004DC) 0x211D- f:00020 d: 285 | A = OR[285]
0x026F (0x0004DE) 0x2720- f:00023 d: 288 | A = A - OR[288]
0x0270 (0x0004E0) 0x8602- f:00103 d: 2 | P = P + 2 (0x0272), A # 0
0x0271 (0x0004E2) 0x7003- f:00070 d: 3 | P = P + 3 (0x0274)
0x0272 (0x0004E4) 0x1004- f:00010 d: 4 | A = 4 (0x0004)
0x0273 (0x0004E6) 0x2907- f:00024 d: 263 | OR[263] = A
0x0274 (0x0004E8) 0x0200- f:00001 d: 0 | EXIT
0x0275 (0x0004EA) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0276 (0x0004EC) 0x2927- f:00024 d: 295 | OR[295] = A
0x0277 (0x0004EE) 0x1800-0x005C f:00014 d: 0 | A = 92 (0x005C)
0x0279 (0x0004F2) 0x2928- f:00024 d: 296 | OR[296] = A
0x027A (0x0004F4) 0x211E- f:00020 d: 286 | A = OR[286]
0x027B (0x0004F6) 0x2929- f:00024 d: 297 | OR[297] = A
0x027C (0x0004F8) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x027D (0x0004FA) 0x292A- f:00024 d: 298 | OR[298] = A
0x027E (0x0004FC) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x027F (0x0004FE) 0x5800- f:00054 d: 0 | B = A
0x0280 (0x000500) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0282 (0x000504) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0283 (0x000506) 0x0200- f:00001 d: 0 | EXIT
0x0284 (0x000508) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0285 (0x00050A) 0x2927- f:00024 d: 295 | OR[295] = A
0x0286 (0x00050C) 0x1800-0x005C f:00014 d: 0 | A = 92 (0x005C)
0x0288 (0x000510) 0x2928- f:00024 d: 296 | OR[296] = A
0x0289 (0x000512) 0x1800-0xFFFF f:00014 d: 0 | A = 65535 (0xFFFF)
0x028B (0x000516) 0x2929- f:00024 d: 297 | OR[297] = A
0x028C (0x000518) 0x1011- f:00010 d: 17 | A = 17 (0x0011)
0x028D (0x00051A) 0x292A- f:00024 d: 298 | OR[298] = A
0x028E (0x00051C) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x028F (0x00051E) 0x5800- f:00054 d: 0 | B = A
0x0290 (0x000520) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0292 (0x000524) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0293 (0x000526) 0x2102- f:00020 d: 258 | A = OR[258]
0x0294 (0x000528) 0x142B- f:00012 d: 43 | A = A + 43 (0x002B)
0x0295 (0x00052A) 0x2908- f:00024 d: 264 | OR[264] = A
0x0296 (0x00052C) 0x211D- f:00020 d: 285 | A = OR[285]
0x0297 (0x00052E) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0298 (0x000530) 0x0200- f:00001 d: 0 | EXIT
0x0299 (0x000532) 0x0400- f:00002 d: 0 | I = 0
0x029A (0x000534) 0x0000- f:00000 d: 0 | PASS
0x029B (0x000536) 0x2101- f:00020 d: 257 | A = OR[257]
0x029C (0x000538) 0x1424- f:00012 d: 36 | A = A + 36 (0x0024)
0x029D (0x00053A) 0x281D- f:00024 d: 29 | OR[29] = A
0x029E (0x00053C) 0x2122- f:00020 d: 290 | A = OR[290]
0x029F (0x00053E) 0x281C- f:00024 d: 28 | OR[28] = A
0x02A0 (0x000540) 0x7E00-0x1E02 f:00077 d: 0 | R = OR[0]+7682 (0x1E02)
0x02A2 (0x000544) 0xEE00- f:00167 d: 0 | IOB , fn007
0x02A3 (0x000546) 0x3101- f:00030 d: 257 | A = (OR[257])
0x02A4 (0x000548) 0x0E08- f:00007 d: 8 | A = A << 8 (0x0008)
0x02A5 (0x00054A) 0x0A01- f:00005 d: 1 | A = A < 1 (0x0001)
0x02A6 (0x00054C) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x02A7 (0x00054E) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x02A8 (0x000550) 0x3901- f:00034 d: 257 | (OR[257]) = A
0x02A9 (0x000552) 0x2101- f:00020 d: 257 | A = OR[257]
0x02AA (0x000554) 0x1418- f:00012 d: 24 | A = A + 24 (0x0018)
0x02AB (0x000556) 0x2913- f:00024 d: 275 | OR[275] = A
0x02AC (0x000558) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x02AD (0x00055A) 0x2927- f:00024 d: 295 | OR[295] = A
0x02AE (0x00055C) 0x2113- f:00020 d: 275 | A = OR[275]
0x02AF (0x00055E) 0x2928- f:00024 d: 296 | OR[296] = A
0x02B0 (0x000560) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02B1 (0x000562) 0x2929- f:00024 d: 297 | OR[297] = A
0x02B2 (0x000564) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02B3 (0x000566) 0x5800- f:00054 d: 0 | B = A
0x02B4 (0x000568) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x02B6 (0x00056C) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02B7 (0x00056E) 0x2006- f:00020 d: 6 | A = OR[6]
0x02B8 (0x000570) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x02B9 (0x000572) 0x2908- f:00024 d: 264 | OR[264] = A
0x02BA (0x000574) 0x3108- f:00030 d: 264 | A = (OR[264])
0x02BB (0x000576) 0x3101- f:00030 d: 257 | A = (OR[257])
0x02BC (0x000578) 0x1A00-0xFEFF f:00015 d: 0 | A = A & 65279 (0xFEFF)
0x02BE (0x00057C) 0x3901- f:00034 d: 257 | (OR[257]) = A
0x02BF (0x00057E) 0x2100- f:00020 d: 256 | A = OR[256]
0x02C0 (0x000580) 0x5800- f:00054 d: 0 | B = A
0x02C1 (0x000582) 0x2006- f:00020 d: 6 | A = OR[6]
0x02C2 (0x000584) 0x140C- f:00012 d: 12 | A = A + 12 (0x000C)
0x02C3 (0x000586) 0x2908- f:00024 d: 264 | OR[264] = A
0x02C4 (0x000588) 0x3108- f:00030 d: 264 | A = (OR[264])
0x02C5 (0x00058A) 0x2907- f:00024 d: 263 | OR[263] = A
0x02C6 (0x00058C) 0x2107- f:00020 d: 263 | A = OR[263]
0x02C7 (0x00058E) 0x8402- f:00102 d: 2 | P = P + 2 (0x02C9), A = 0
0x02C8 (0x000590) 0x0200- f:00001 d: 0 | EXIT
0x02C9 (0x000592) 0x4400- f:00042 d: 0 | C = 1, IOB = DN
0x02CA (0x000594) 0x8002- f:00100 d: 2 | P = P + 2 (0x02CC), C = 0
0x02CB (0x000596) 0x7004- f:00070 d: 4 | P = P + 4 (0x02CF)
0x02CC (0x000598) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x02CD (0x00059A) 0x2907- f:00024 d: 263 | OR[263] = A
0x02CE (0x00059C) 0x7006- f:00070 d: 6 | P = P + 6 (0x02D4)
0x02CF (0x00059E) 0x4600- f:00043 d: 0 | C = 1, IOB = BZ
0x02D0 (0x0005A0) 0x8202- f:00101 d: 2 | P = P + 2 (0x02D2), C = 1
0x02D1 (0x0005A2) 0x7003- f:00070 d: 3 | P = P + 3 (0x02D4)
0x02D2 (0x0005A4) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x02D3 (0x0005A6) 0x2907- f:00024 d: 263 | OR[263] = A
0x02D4 (0x0005A8) 0xF400- f:00172 d: 0 | IOB , fn012
0x02D5 (0x0005AA) 0x291C- f:00024 d: 284 | OR[284] = A
0x02D6 (0x0005AC) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x02D7 (0x0005AE) 0x2B17- f:00025 d: 279 | OR[279] = A + OR[279]
0x02D8 (0x0005B0) 0xF600- f:00173 d: 0 | IOB , fn013
0x02D9 (0x0005B2) 0x291D- f:00024 d: 285 | OR[285] = A
0x02DA (0x0005B4) 0x2102- f:00020 d: 258 | A = OR[258]
0x02DB (0x0005B6) 0x142A- f:00012 d: 42 | A = A + 42 (0x002A)
0x02DC (0x0005B8) 0x2908- f:00024 d: 264 | OR[264] = A
0x02DD (0x0005BA) 0x211C- f:00020 d: 284 | A = OR[284]
0x02DE (0x0005BC) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x02DF (0x0005BE) 0x0200- f:00001 d: 0 | EXIT
0x02E0 (0x0005C0) 0x1800-0x1000 f:00014 d: 0 | A = 4096 (0x1000)
0x02E2 (0x0005C4) 0x4400- f:00042 d: 0 | C = 1, IOB = DN
0x02E3 (0x0005C6) 0x8205- f:00101 d: 5 | P = P + 5 (0x02E8), C = 1
0x02E4 (0x0005C8) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x02E5 (0x0005CA) 0x8602- f:00103 d: 2 | P = P + 2 (0x02E7), A # 0
0x02E6 (0x0005CC) 0x0200- f:00001 d: 0 | EXIT
0x02E7 (0x0005CE) 0x7205- f:00071 d: 5 | P = P - 5 (0x02E2)
0x02E8 (0x0005D0) 0x0200- f:00001 d: 0 | EXIT
0x02E9 (0x0005D2) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02EA (0x0005D4) 0x2913- f:00024 d: 275 | OR[275] = A
0x02EB (0x0005D6) 0x7003- f:00070 d: 3 | P = P + 3 (0x02EE)
0x02EC (0x0005D8) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x02ED (0x0005DA) 0x2913- f:00024 d: 275 | OR[275] = A
0x02EE (0x0005DC) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x02EF (0x0005DE) 0x2927- f:00024 d: 295 | OR[295] = A
0x02F0 (0x0005E0) 0x1800-0x0058 f:00014 d: 0 | A = 88 (0x0058)
0x02F2 (0x0005E4) 0x2928- f:00024 d: 296 | OR[296] = A
0x02F3 (0x0005E6) 0x2113- f:00020 d: 275 | A = OR[275]
0x02F4 (0x0005E8) 0x2929- f:00024 d: 297 | OR[297] = A
0x02F5 (0x0005EA) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02F6 (0x0005EC) 0x5800- f:00054 d: 0 | B = A
0x02F7 (0x0005EE) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x02F9 (0x0005F2) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02FA (0x0005F4) 0x0200- f:00001 d: 0 | EXIT
0x02FB (0x0005F6) 0x2100- f:00020 d: 256 | A = OR[256]
0x02FC (0x0005F8) 0x5800- f:00054 d: 0 | B = A
0x02FD (0x0005FA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02FE (0x0005FC) 0x2907- f:00024 d: 263 | OR[263] = A
0x02FF (0x0005FE) 0xE000- f:00160 d: 0 | IOB , fn000
0x0300 (0x000600) 0x0000- f:00000 d: 0 | PASS
0x0301 (0x000602) 0x4400- f:00042 d: 0 | C = 1, IOB = DN
0x0302 (0x000604) 0x8204- f:00101 d: 4 | P = P + 4 (0x0306), C = 1
0x0303 (0x000606) 0x4600- f:00043 d: 0 | C = 1, IOB = BZ
0x0304 (0x000608) 0x8202- f:00101 d: 2 | P = P + 2 (0x0306), C = 1
0x0305 (0x00060A) 0x7003- f:00070 d: 3 | P = P + 3 (0x0308)
0x0306 (0x00060C) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0307 (0x00060E) 0x2907- f:00024 d: 263 | OR[263] = A
0x0308 (0x000610) 0x0200- f:00001 d: 0 | EXIT
0x0309 (0x000612) 0x0000- f:00000 d: 0 | PASS
0x030A (0x000614) 0x0000- f:00000 d: 0 | PASS
0x030B (0x000616) 0x0000- f:00000 d: 0 | PASS
|
enduser/netmeeting/av/codecs/intel/h261/i386/e15vlc.asm | npocmaka/Windows-Server-2003 | 17 | 2701 | <reponame>npocmaka/Windows-Server-2003<gh_stars>10-100
; ++ ========================================================================
;
; INTEL CORPORATION PROPRIETARY INFORMATION
;
; This software is supplied under the terms of a license
; agreement or nondisclosure agreement with Intel Corporation
; and may not be copied or disclosed except in accordance
; with the terms of that agreement.
;
; Copyright (c) 1995 Intel Corporation. All Rights Reserved.
;
; ========================================================================
;
;
; Declaration:
; void MBEncodeVLC (
; char * pMBRVS_Luma,
; char * pMBRVS_Chroma,
; unsigned int CodedBlkPattern,
; unsigned char ** pBitStream,
; unsigned char * pBitOffset,
; int IntraFlag,
; int MMxFlag
; );
; Description:
; This function encodes a macroblock's worth of RLE values.
; The RLE values are provided to me in a list of triplets
; where the triplets consist of RUN, LEVEL, and SIGN, where
; each element is a BYTE.
;
; Register Usage:
; ESI -- RLE stream cursor
; EDI -- Bit stream cursor
; EDX -- Bit stream offset
;
; $Header: S:\h26x\src\enc\e15vlc.asv 1.9 21 Oct 1996 09:06:42 RHAZRA $
;
; $Log: S:\h26x\src\enc\e15vlc.asv $
;//
;// Rev 1.9 21 Oct 1996 09:06:42 RHAZRA
;//
;// Check for 0 level and change to 127 if so.
;//
;// Rev 1.8 01 Nov 1995 08:59:14 DBRUCKS
;// Don't output EOB on empty INTRA
;//
;// Rev 1.7 23 Oct 1995 16:38:08 DBRUCKS
;// fix sizeof VLC TCOEF Table
;//
;// Rev 1.6 28 Sep 1995 11:58:04 BECHOLS
;// Added exception code to handle the special case where the first code of
;// an inter block is 11s, and I change it to 1s per the spec. I also added
;// a read to PutBits to preload the cache for the write. I also looped the
;// main function to reduce code size.
;//
;// Rev 1.5 26 Sep 1995 13:32:24 DBRUCKS
;// write EOB after DC in empty Intra
;//
;// Rev 1.4 25 Sep 1995 17:23:12 BECHOLS
;// Modified the code to write what I think will be a valid H261 bit stream.
;// Also modified the code for optimum performance.
;//
;// Rev 1.3 21 Sep 1995 18:17:14 BECHOLS
;//
;// Change the way I handle the VLC table called VLC_TCOEF_TBL to account
;// for its new format as initialized in E1MBENC.CPP. The code is work in prog
;//
;// Rev 1.2 20 Sep 1995 17:34:42 BECHOLS
;//
;// made correction to macro.
;//
;// Rev 1.1 20 Sep 1995 16:56:54 BECHOLS
;//
;// Updated to the optimized version, and removed the TCOEF_LAST_TBL
;// because H261 doesn't use it. I changed the TCOEF_TBL to a single
;// DWORD and will pack the size and code to save data space.
;
; -- ========================================================================
.486
.MODEL flat, c
; ++ ========================================================================
; Name mangling in C++ forces me to declare these tables in the ASM file
; and make them externally available to C++ as extern "C" ...
; -- ========================================================================
PUBLIC FLC_INTRADC
PUBLIC VLC_TCOEF_TBL
TCOEF_ESCAPE_FIELDLEN EQU 6
TCOEF_ESCAPE_FIELDVAL EQU 1
TCOEF_EOB_FIELDLEN EQU 2
TCOEF_EOB_FIELDVAL EQU 2
TCOEF_RUN_FIELDLEN EQU 6
TCOEF_LEVEL_FIELDLEN EQU 8
MAX_TABLE_LEVEL EQU 12
; ++ ========================================================================
; RLS (Run Level Sign) Structure is defined just to make the code a little
; more readable.
; -- ========================================================================
RLS STRUCT
Run BYTE ?
Level BYTE ?
Sign BYTE ?
RLS ENDS
; ++ ========================================================================
; The PutBits macro puts a Variable Length Code into the bit stream. It
; expects registers to contain the correct information as follows.
; EDX -- Field Length
; EAX -- Field Value
; EDI -- Pointer to the Bitstream Pointer
; EBX -- Pointer to the Bitstream Offset
; The contents of EDI and EBX are modified and EDX and EAX are trashed.
; -- ========================================================================
PutBits MACRO
push esi
push ecx
xor ecx, ecx
mov cl, BYTE PTR [ebx] ;; Get the Bit Offset.
add edx, ecx ;; Add it to the field length.
mov ecx, 32 ;; EAX <<= (32 - (EDX + [EBX]))
sub ecx, edx ;; EDX = Field Length + Bit Offset.
mov esi, DWORD PTR [edi] ;; Set ESI to Bit Stream.
shl eax, cl ;;
bswap eax ;; Swaps byte order in EAX.
mov ecx, DWORD PTR [esi] ;; Preload cache.
or DWORD PTR [esi], eax ;; Write value to bit stream.
mov eax, edx
shr eax, 3
add [edi], eax ;; Update Bit Stream Pointer.
and edx, 000000007h
mov BYTE PTR [ebx], dl ;; Update Bit Stream Offset.
pop ecx
pop esi
ENDM
; ++ ========================================================================
; PutRunLev macro writes the ESCAPE code and Last bit, then the RUN length,
; and then the LEVEL into the stream. It assumes the following registers.
; ESI -- Pointer to RLE stream.
; EDI -- Pointer to the Bitstream Pointer
; EBX -- Pointer to the Bitstream Offset
; The contents of EDI and EBX are modified and EDX, ECX and EAX are trashed.
; -- ========================================================================
PutRunLev MACRO
LOCAL NotZero, NoClamp, NotNegative
mov eax, TCOEF_ESCAPE_FIELDVAL
mov edx, TCOEF_ESCAPE_FIELDLEN
PutBits ;; Write ESCAPE.
mov al, (RLS PTR [esi]).Run ;; Retrieve Run Length.
mov edx, TCOEF_RUN_FIELDLEN
PutBits ;; Write RUN length.
mov al, (RLS PTR [esi]).Level ;; Retrieve Level.
sub eax, 1 ; new
NotZero:
cmp eax, 127 ; new - was 128
jb NoClamp
mov eax, 126 ; new - was 127
NoClamp:
add eax, 1 ; new
cmp (RLS PTR [esi]).Sign, 0FFh
jne NotNegative
mov ecx, eax
xor eax, eax
sub eax, ecx
and eax, 0000000FFh
NotNegative:
mov edx, TCOEF_LEVEL_FIELDLEN
PutBits ;; Write LEVEL.
ENDM
; ++ ========================================================================
; PutVLC macro writes the Variable Length Code and its sign bit into the
; bit stream. It expects the registers to be set up as follows.
; EDX -- VLC Code Length
; ECX -- First Code Written Flag.
; EAX -- VLC Bit Code
; ESI -- Pointer to RLE stream.
; EDI -- Pointer to the Bitstream Pointer
; EBX -- Pointer to the Bitstream Offset
; It checks ECX and if Zero (0) then it must check for the special case of
; code length of 3 which indicates the special case code. The contents of
; EDI and EBX are modified and EDX, ECX, and EAX are trashed.
; -- ========================================================================
PutVLC MACRO
LOCAL NotSpecial
cmp ecx, 0 ;; If this is the first code to
jnz NotSpecial ;; get written and it is the
cmp edx, 3 ;; the special code for an inter
jnz NotSpecial ;; block, then we need to change
and eax, 000000003h ;; the code and its length, before
dec edx ;; writing it to the stream.
NotSpecial:
mov cl, (RLS PTR [esi]).Sign ;; Get sign bit which is [ 0 | -1 ]
and ecx, 000000001h ;; Mask off all but the low bit
or eax, ecx ;; and place it in VLC.
PutBits ;; Write the signed VLC into stream.
ENDM
; ++ ========================================================================
; IndexTable macro determines the pointer value as indexed into the table
; of coefficients. It assumes the following registers.
; ESI -- Pointer to RLE stream.
; EAX -- The level which is one (1) based.
; EDX -- The base pointer to the coefficient array.
; The EDX register is modified, EAX is trashed, and ECX is preserved
; -- ========================================================================
IndexTable MACRO
push ecx ;; Save first code written flag.
lea edx, VLC_TCOEF_TBL ;; Point to proper table,
dec eax ;; Zero base the level value.
shl eax, 6 ;; EAX is # of run values per level
mov ecx, eax ;; added to the run value.
xor eax, eax ;;
mov al, (RLS PTR [esi]).Run ;;
add eax, ecx ;;
shl eax, 2 ;; The array has DWORDs (4 bytes)
add edx, eax ;; Add the index to the array.
pop ecx ;; Restore first code written flag.
ENDM
; ++ ========================================================================
; WriteOneCode macro takes one RLE code from the triplet list and VLC
; encodes it, and writes it to the bit stream. It expects that the
; following registers will be set as shown. It checks ECX and if Zero (0)
; then it must check for the special case of Run == 0 and Level == 1.
; ESI -- Pointer to RLE stream.
; EDI -- Pointer to the Bitstream Pointer.
; EBX -- Pointer to the Bitstream Offset.
; ECX -- First Code Written Flag.
; The contents of EDI and EBX are modified and EDX , ECX, and EAX
; are trashed.
; -- ========================================================================
WriteOneCode MACRO
LOCAL RunLevel, VLCDone, NotZero
mov al, (RLS PTR [esi]).Level ;; Get the level value and check
test al, al ;; NEW
jnz NotZero ;; NEW
mov al, 127 ;; NEW
NotZero: ;; NEW
cmp eax, MAX_TABLE_LEVEL ;; it against the max table level.
jg RunLevel ;;
IndexTable ;; Sets EDX to table index
mov eax, DWORD PTR [edx] ;; Get the VLC code from table.
cmp eax, 00000FFFFh ;; Is this an escape indicator?
je RunLevel ;; If so then do RLE processing.
mov edx, eax
and eax, 00000FFFFh
shr edx, 16
PutVLC ;; Write the Variable code.
jmp VLCDone
RunLevel:
PutRunLev ;; Write the ESC RUN LEV stuff.
VLCDone:
ENDM
; ++ ========================================================================
; WriteIntraDC macro writes the Intra DC value into the bit stream. It
; expects the following registers to be set correctly.
; ESI -- Pointer to RLE stream.
; EDI -- Pointer to the Bitstream Pointer
; EBX -- Pointer to the Bitstream Offset
; The contents of EDI and EBX are modified, ESI is updated, and EDX and
; EAX are preserved.
; -- ========================================================================
WriteIntraDC MACRO
push eax
push edx
lea edx, FLC_INTRADC ;; Form index into Intra DC
mov al, (RLS PTR [esi]).Level ;; array.
add edx, eax ;;
mov al, BYTE PTR [edx] ;; Get Intra DC value.
mov edx, 8 ;; Set size of write to 8 bits.
PutBits ;; Write the Intra DC value.
add esi, SIZEOF RLS ;; Point to next triplet.
pop edx
pop eax
ENDM
; ++ ========================================================================
; WriteEndOfBlock macro writes the end of block code into the stream. It
; assumes the the registers will be set up as follows.
; EDI -- Pointer to the Bitstream Pointer
; EBX -- Pointer to the Bitstream Offset
; The contents of EDI and EBX are modified, and EDX and EAX are trashed.
; -- ========================================================================
WriteEndOfBlock MACRO
mov eax, TCOEF_EOB_FIELDVAL
mov edx, TCOEF_EOB_FIELDLEN
PutBits ;; Write EOB.
ENDM
; ++ ========================================================================
; WriteOneBlock macro writes all the coefficients for a single block of the
; macroblock. It assumes that the registers will be set as follows.
; ESI -- Pointer to RLE stream.
; EDI -- Pointer to the Bitstream Pointer
; EBX -- Pointer to the Bitstream Offset
; EDX -- Coded Block Pattern (CBP)
; ECX -- Intra/Inter Flag
; EAX -- CBP Mask.
; The contents of EDI and EBX are modified and EDX , ECX, and EAX are
; preserved.
; -- ========================================================================
WriteOneBlock MACRO
LOCAL NotIntra, WriteDone, WriteCodes, WriteExit
push eax
push edx
cmp ecx, 1 ;; Check to see if this is an
jne NotIntra ;; Intra block, and if so,
WriteIntraDC ;; write the DC value.
and eax, edx ;; Check CBP to see if done.
jnz WriteCodes
WriteEndOfBlock
jmp WriteExit
NotIntra:
and eax, edx ;; Check CBP to see if done.
jnz WriteCodes
jmp WriteExit
WriteCodes:
mov al, (RLS PTR [esi]).Run ;; Get the RUN value.
cmp eax, 0000000FFh ;; Check to see if done.
je WriteDone ;; If not, then continue to
WriteOneCode ;; write the codes in this
add esi, SIZEOF RLS ;; block until done.
mov ecx, 1 ;; Flag WriteOneCode that not
jmp WriteCodes ;; first code.
WriteDone:
WriteEndOfBlock
add esi, SIZEOF RLS ;; Bump to next block.
WriteExit:
pop edx
pop eax
ENDM
.DATA
FLC_INTRADC DB 256 DUP (?)
VLC_TCOEF_TBL DD (64 * 16) DUP (?)
.CODE
; ++ ========================================================================
; This is the C function call entry point. This function variable length
; encodes an entire macroblock, one block at a time.
; -- ========================================================================
MBEncodeVLC PROC PUBLIC USES edi esi ebx ecx, pMBRVS_Luma:DWORD, pMBRVS_Chroma:DWORD, CodedBlockPattern:DWORD, ppBitStream:DWORD, pBitOffset:DWORD, IntraFlag:DWORD, MMxFlag:DWORD
mov esi, pMBRVS_Luma
mov edi, ppBitStream
mov ebx, pBitOffset
mov edx, CodedBlockPattern
mov esi, [esi]
mov eax, 1 ; CBP Mask.
LumaWriteLoop:
test eax, 000000010h ; When EAX bit shifts to this
jnz LumaBlocksDone ; position, we are done with Luma.
mov ecx, IntraFlag
WriteOneBlock
shl eax, 1 ; Shift CBP mask to next block.
jmp LumaWriteLoop
LumaBlocksDone:
mov ecx, MMxFlag
test ecx, 1
jz ChromaWriteLoop
mov ecx, pMBRVS_Luma
mov [ecx],esi
mov ecx, pMBRVS_Chroma
mov esi,[ecx]
ChromaWriteLoop:
test eax, 000000040h ; When EAX bit shifts to this
jnz ChromaBlocksDone ; position, we are done.
mov ecx, IntraFlag
WriteOneBlock
shl eax, 1 ; Shift CBP mask to next block.
jmp ChromaWriteLoop
ChromaBlocksDone:
mov eax, pMBRVS_Chroma
mov ecx, MMxFlag
test ecx, 1
jz MacroBlockDone
mov [eax],esi
MacroBlockDone:
ret
MBEncodeVLC ENDP
END
|
kill.asm | dylsugar/cs461_hw7 | 0 | 7772 | <filename>kill.asm
_kill: file format elf64-x86-64
Disassembly of section .text:
0000000000001000 <main>:
#include "stat.h"
#include "user.h"
int
main(int argc, char **argv)
{
1000: f3 0f 1e fa endbr64
1004: 55 push %rbp
1005: 48 89 e5 mov %rsp,%rbp
1008: 48 83 ec 20 sub $0x20,%rsp
100c: 89 7d ec mov %edi,-0x14(%rbp)
100f: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int i;
if(argc < 2){
1013: 83 7d ec 01 cmpl $0x1,-0x14(%rbp)
1017: 7f 2c jg 1045 <main+0x45>
printf(2, "usage: kill pid...\n");
1019: 48 be e8 1d 00 00 00 movabs $0x1de8,%rsi
1020: 00 00 00
1023: bf 02 00 00 00 mov $0x2,%edi
1028: b8 00 00 00 00 mov $0x0,%eax
102d: 48 ba d4 16 00 00 00 movabs $0x16d4,%rdx
1034: 00 00 00
1037: ff d2 callq *%rdx
exit();
1039: 48 b8 dd 13 00 00 00 movabs $0x13dd,%rax
1040: 00 00 00
1043: ff d0 callq *%rax
}
for(i=1; i<argc; i++)
1045: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%rbp)
104c: eb 38 jmp 1086 <main+0x86>
kill(atoi(argv[i]));
104e: 8b 45 fc mov -0x4(%rbp),%eax
1051: 48 98 cltq
1053: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
105a: 00
105b: 48 8b 45 e0 mov -0x20(%rbp),%rax
105f: 48 01 d0 add %rdx,%rax
1062: 48 8b 00 mov (%rax),%rax
1065: 48 89 c7 mov %rax,%rdi
1068: 48 b8 1b 13 00 00 00 movabs $0x131b,%rax
106f: 00 00 00
1072: ff d0 callq *%rax
1074: 89 c7 mov %eax,%edi
1076: 48 b8 2b 14 00 00 00 movabs $0x142b,%rax
107d: 00 00 00
1080: ff d0 callq *%rax
for(i=1; i<argc; i++)
1082: 83 45 fc 01 addl $0x1,-0x4(%rbp)
1086: 8b 45 fc mov -0x4(%rbp),%eax
1089: 3b 45 ec cmp -0x14(%rbp),%eax
108c: 7c c0 jl 104e <main+0x4e>
exit();
108e: 48 b8 dd 13 00 00 00 movabs $0x13dd,%rax
1095: 00 00 00
1098: ff d0 callq *%rax
000000000000109a <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
109a: f3 0f 1e fa endbr64
109e: 55 push %rbp
109f: 48 89 e5 mov %rsp,%rbp
10a2: 48 83 ec 10 sub $0x10,%rsp
10a6: 48 89 7d f8 mov %rdi,-0x8(%rbp)
10aa: 89 75 f4 mov %esi,-0xc(%rbp)
10ad: 89 55 f0 mov %edx,-0x10(%rbp)
asm volatile("cld; rep stosb" :
10b0: 48 8b 4d f8 mov -0x8(%rbp),%rcx
10b4: 8b 55 f0 mov -0x10(%rbp),%edx
10b7: 8b 45 f4 mov -0xc(%rbp),%eax
10ba: 48 89 ce mov %rcx,%rsi
10bd: 48 89 f7 mov %rsi,%rdi
10c0: 89 d1 mov %edx,%ecx
10c2: fc cld
10c3: f3 aa rep stos %al,%es:(%rdi)
10c5: 89 ca mov %ecx,%edx
10c7: 48 89 fe mov %rdi,%rsi
10ca: 48 89 75 f8 mov %rsi,-0x8(%rbp)
10ce: 89 55 f0 mov %edx,-0x10(%rbp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
10d1: 90 nop
10d2: c9 leaveq
10d3: c3 retq
00000000000010d4 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
10d4: f3 0f 1e fa endbr64
10d8: 55 push %rbp
10d9: 48 89 e5 mov %rsp,%rbp
10dc: 48 83 ec 20 sub $0x20,%rsp
10e0: 48 89 7d e8 mov %rdi,-0x18(%rbp)
10e4: 48 89 75 e0 mov %rsi,-0x20(%rbp)
char *os;
os = s;
10e8: 48 8b 45 e8 mov -0x18(%rbp),%rax
10ec: 48 89 45 f8 mov %rax,-0x8(%rbp)
while((*s++ = *t++) != 0)
10f0: 90 nop
10f1: 48 8b 55 e0 mov -0x20(%rbp),%rdx
10f5: 48 8d 42 01 lea 0x1(%rdx),%rax
10f9: 48 89 45 e0 mov %rax,-0x20(%rbp)
10fd: 48 8b 45 e8 mov -0x18(%rbp),%rax
1101: 48 8d 48 01 lea 0x1(%rax),%rcx
1105: 48 89 4d e8 mov %rcx,-0x18(%rbp)
1109: 0f b6 12 movzbl (%rdx),%edx
110c: 88 10 mov %dl,(%rax)
110e: 0f b6 00 movzbl (%rax),%eax
1111: 84 c0 test %al,%al
1113: 75 dc jne 10f1 <strcpy+0x1d>
;
return os;
1115: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
1119: c9 leaveq
111a: c3 retq
000000000000111b <strcmp>:
int
strcmp(const char *p, const char *q)
{
111b: f3 0f 1e fa endbr64
111f: 55 push %rbp
1120: 48 89 e5 mov %rsp,%rbp
1123: 48 83 ec 10 sub $0x10,%rsp
1127: 48 89 7d f8 mov %rdi,-0x8(%rbp)
112b: 48 89 75 f0 mov %rsi,-0x10(%rbp)
while(*p && *p == *q)
112f: eb 0a jmp 113b <strcmp+0x20>
p++, q++;
1131: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
1136: 48 83 45 f0 01 addq $0x1,-0x10(%rbp)
while(*p && *p == *q)
113b: 48 8b 45 f8 mov -0x8(%rbp),%rax
113f: 0f b6 00 movzbl (%rax),%eax
1142: 84 c0 test %al,%al
1144: 74 12 je 1158 <strcmp+0x3d>
1146: 48 8b 45 f8 mov -0x8(%rbp),%rax
114a: 0f b6 10 movzbl (%rax),%edx
114d: 48 8b 45 f0 mov -0x10(%rbp),%rax
1151: 0f b6 00 movzbl (%rax),%eax
1154: 38 c2 cmp %al,%dl
1156: 74 d9 je 1131 <strcmp+0x16>
return (uchar)*p - (uchar)*q;
1158: 48 8b 45 f8 mov -0x8(%rbp),%rax
115c: 0f b6 00 movzbl (%rax),%eax
115f: 0f b6 d0 movzbl %al,%edx
1162: 48 8b 45 f0 mov -0x10(%rbp),%rax
1166: 0f b6 00 movzbl (%rax),%eax
1169: 0f b6 c0 movzbl %al,%eax
116c: 29 c2 sub %eax,%edx
116e: 89 d0 mov %edx,%eax
}
1170: c9 leaveq
1171: c3 retq
0000000000001172 <strlen>:
uint
strlen(char *s)
{
1172: f3 0f 1e fa endbr64
1176: 55 push %rbp
1177: 48 89 e5 mov %rsp,%rbp
117a: 48 83 ec 18 sub $0x18,%rsp
117e: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
for(n = 0; s[n]; n++)
1182: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
1189: eb 04 jmp 118f <strlen+0x1d>
118b: 83 45 fc 01 addl $0x1,-0x4(%rbp)
118f: 8b 45 fc mov -0x4(%rbp),%eax
1192: 48 63 d0 movslq %eax,%rdx
1195: 48 8b 45 e8 mov -0x18(%rbp),%rax
1199: 48 01 d0 add %rdx,%rax
119c: 0f b6 00 movzbl (%rax),%eax
119f: 84 c0 test %al,%al
11a1: 75 e8 jne 118b <strlen+0x19>
;
return n;
11a3: 8b 45 fc mov -0x4(%rbp),%eax
}
11a6: c9 leaveq
11a7: c3 retq
00000000000011a8 <memset>:
void*
memset(void *dst, int c, uint n)
{
11a8: f3 0f 1e fa endbr64
11ac: 55 push %rbp
11ad: 48 89 e5 mov %rsp,%rbp
11b0: 48 83 ec 10 sub $0x10,%rsp
11b4: 48 89 7d f8 mov %rdi,-0x8(%rbp)
11b8: 89 75 f4 mov %esi,-0xc(%rbp)
11bb: 89 55 f0 mov %edx,-0x10(%rbp)
stosb(dst, c, n);
11be: 8b 55 f0 mov -0x10(%rbp),%edx
11c1: 8b 4d f4 mov -0xc(%rbp),%ecx
11c4: 48 8b 45 f8 mov -0x8(%rbp),%rax
11c8: 89 ce mov %ecx,%esi
11ca: 48 89 c7 mov %rax,%rdi
11cd: 48 b8 9a 10 00 00 00 movabs $0x109a,%rax
11d4: 00 00 00
11d7: ff d0 callq *%rax
return dst;
11d9: 48 8b 45 f8 mov -0x8(%rbp),%rax
}
11dd: c9 leaveq
11de: c3 retq
00000000000011df <strchr>:
char*
strchr(const char *s, char c)
{
11df: f3 0f 1e fa endbr64
11e3: 55 push %rbp
11e4: 48 89 e5 mov %rsp,%rbp
11e7: 48 83 ec 10 sub $0x10,%rsp
11eb: 48 89 7d f8 mov %rdi,-0x8(%rbp)
11ef: 89 f0 mov %esi,%eax
11f1: 88 45 f4 mov %al,-0xc(%rbp)
for(; *s; s++)
11f4: eb 17 jmp 120d <strchr+0x2e>
if(*s == c)
11f6: 48 8b 45 f8 mov -0x8(%rbp),%rax
11fa: 0f b6 00 movzbl (%rax),%eax
11fd: 38 45 f4 cmp %al,-0xc(%rbp)
1200: 75 06 jne 1208 <strchr+0x29>
return (char*)s;
1202: 48 8b 45 f8 mov -0x8(%rbp),%rax
1206: eb 15 jmp 121d <strchr+0x3e>
for(; *s; s++)
1208: 48 83 45 f8 01 addq $0x1,-0x8(%rbp)
120d: 48 8b 45 f8 mov -0x8(%rbp),%rax
1211: 0f b6 00 movzbl (%rax),%eax
1214: 84 c0 test %al,%al
1216: 75 de jne 11f6 <strchr+0x17>
return 0;
1218: b8 00 00 00 00 mov $0x0,%eax
}
121d: c9 leaveq
121e: c3 retq
000000000000121f <gets>:
char*
gets(char *buf, int max)
{
121f: f3 0f 1e fa endbr64
1223: 55 push %rbp
1224: 48 89 e5 mov %rsp,%rbp
1227: 48 83 ec 20 sub $0x20,%rsp
122b: 48 89 7d e8 mov %rdi,-0x18(%rbp)
122f: 89 75 e4 mov %esi,-0x1c(%rbp)
int i, cc;
char c;
for(i=0; i+1 < max; ){
1232: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
1239: eb 4f jmp 128a <gets+0x6b>
cc = read(0, &c, 1);
123b: 48 8d 45 f7 lea -0x9(%rbp),%rax
123f: ba 01 00 00 00 mov $0x1,%edx
1244: 48 89 c6 mov %rax,%rsi
1247: bf 00 00 00 00 mov $0x0,%edi
124c: 48 b8 04 14 00 00 00 movabs $0x1404,%rax
1253: 00 00 00
1256: ff d0 callq *%rax
1258: 89 45 f8 mov %eax,-0x8(%rbp)
if(cc < 1)
125b: 83 7d f8 00 cmpl $0x0,-0x8(%rbp)
125f: 7e 36 jle 1297 <gets+0x78>
break;
buf[i++] = c;
1261: 8b 45 fc mov -0x4(%rbp),%eax
1264: 8d 50 01 lea 0x1(%rax),%edx
1267: 89 55 fc mov %edx,-0x4(%rbp)
126a: 48 63 d0 movslq %eax,%rdx
126d: 48 8b 45 e8 mov -0x18(%rbp),%rax
1271: 48 01 c2 add %rax,%rdx
1274: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
1278: 88 02 mov %al,(%rdx)
if(c == '\n' || c == '\r')
127a: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
127e: 3c 0a cmp $0xa,%al
1280: 74 16 je 1298 <gets+0x79>
1282: 0f b6 45 f7 movzbl -0x9(%rbp),%eax
1286: 3c 0d cmp $0xd,%al
1288: 74 0e je 1298 <gets+0x79>
for(i=0; i+1 < max; ){
128a: 8b 45 fc mov -0x4(%rbp),%eax
128d: 83 c0 01 add $0x1,%eax
1290: 39 45 e4 cmp %eax,-0x1c(%rbp)
1293: 7f a6 jg 123b <gets+0x1c>
1295: eb 01 jmp 1298 <gets+0x79>
break;
1297: 90 nop
break;
}
buf[i] = '\0';
1298: 8b 45 fc mov -0x4(%rbp),%eax
129b: 48 63 d0 movslq %eax,%rdx
129e: 48 8b 45 e8 mov -0x18(%rbp),%rax
12a2: 48 01 d0 add %rdx,%rax
12a5: c6 00 00 movb $0x0,(%rax)
return buf;
12a8: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
12ac: c9 leaveq
12ad: c3 retq
00000000000012ae <stat>:
int
stat(char *n, struct stat *st)
{
12ae: f3 0f 1e fa endbr64
12b2: 55 push %rbp
12b3: 48 89 e5 mov %rsp,%rbp
12b6: 48 83 ec 20 sub $0x20,%rsp
12ba: 48 89 7d e8 mov %rdi,-0x18(%rbp)
12be: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int fd;
int r;
fd = open(n, O_RDONLY);
12c2: 48 8b 45 e8 mov -0x18(%rbp),%rax
12c6: be 00 00 00 00 mov $0x0,%esi
12cb: 48 89 c7 mov %rax,%rdi
12ce: 48 b8 45 14 00 00 00 movabs $0x1445,%rax
12d5: 00 00 00
12d8: ff d0 callq *%rax
12da: 89 45 fc mov %eax,-0x4(%rbp)
if(fd < 0)
12dd: 83 7d fc 00 cmpl $0x0,-0x4(%rbp)
12e1: 79 07 jns 12ea <stat+0x3c>
return -1;
12e3: b8 ff ff ff ff mov $0xffffffff,%eax
12e8: eb 2f jmp 1319 <stat+0x6b>
r = fstat(fd, st);
12ea: 48 8b 55 e0 mov -0x20(%rbp),%rdx
12ee: 8b 45 fc mov -0x4(%rbp),%eax
12f1: 48 89 d6 mov %rdx,%rsi
12f4: 89 c7 mov %eax,%edi
12f6: 48 b8 6c 14 00 00 00 movabs $0x146c,%rax
12fd: 00 00 00
1300: ff d0 callq *%rax
1302: 89 45 f8 mov %eax,-0x8(%rbp)
close(fd);
1305: 8b 45 fc mov -0x4(%rbp),%eax
1308: 89 c7 mov %eax,%edi
130a: 48 b8 1e 14 00 00 00 movabs $0x141e,%rax
1311: 00 00 00
1314: ff d0 callq *%rax
return r;
1316: 8b 45 f8 mov -0x8(%rbp),%eax
}
1319: c9 leaveq
131a: c3 retq
000000000000131b <atoi>:
int
atoi(const char *s)
{
131b: f3 0f 1e fa endbr64
131f: 55 push %rbp
1320: 48 89 e5 mov %rsp,%rbp
1323: 48 83 ec 18 sub $0x18,%rsp
1327: 48 89 7d e8 mov %rdi,-0x18(%rbp)
int n;
n = 0;
132b: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
while('0' <= *s && *s <= '9')
1332: eb 28 jmp 135c <atoi+0x41>
n = n*10 + *s++ - '0';
1334: 8b 55 fc mov -0x4(%rbp),%edx
1337: 89 d0 mov %edx,%eax
1339: c1 e0 02 shl $0x2,%eax
133c: 01 d0 add %edx,%eax
133e: 01 c0 add %eax,%eax
1340: 89 c1 mov %eax,%ecx
1342: 48 8b 45 e8 mov -0x18(%rbp),%rax
1346: 48 8d 50 01 lea 0x1(%rax),%rdx
134a: 48 89 55 e8 mov %rdx,-0x18(%rbp)
134e: 0f b6 00 movzbl (%rax),%eax
1351: 0f be c0 movsbl %al,%eax
1354: 01 c8 add %ecx,%eax
1356: 83 e8 30 sub $0x30,%eax
1359: 89 45 fc mov %eax,-0x4(%rbp)
while('0' <= *s && *s <= '9')
135c: 48 8b 45 e8 mov -0x18(%rbp),%rax
1360: 0f b6 00 movzbl (%rax),%eax
1363: 3c 2f cmp $0x2f,%al
1365: 7e 0b jle 1372 <atoi+0x57>
1367: 48 8b 45 e8 mov -0x18(%rbp),%rax
136b: 0f b6 00 movzbl (%rax),%eax
136e: 3c 39 cmp $0x39,%al
1370: 7e c2 jle 1334 <atoi+0x19>
return n;
1372: 8b 45 fc mov -0x4(%rbp),%eax
}
1375: c9 leaveq
1376: c3 retq
0000000000001377 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
1377: f3 0f 1e fa endbr64
137b: 55 push %rbp
137c: 48 89 e5 mov %rsp,%rbp
137f: 48 83 ec 28 sub $0x28,%rsp
1383: 48 89 7d e8 mov %rdi,-0x18(%rbp)
1387: 48 89 75 e0 mov %rsi,-0x20(%rbp)
138b: 89 55 dc mov %edx,-0x24(%rbp)
char *dst, *src;
dst = vdst;
138e: 48 8b 45 e8 mov -0x18(%rbp),%rax
1392: 48 89 45 f8 mov %rax,-0x8(%rbp)
src = vsrc;
1396: 48 8b 45 e0 mov -0x20(%rbp),%rax
139a: 48 89 45 f0 mov %rax,-0x10(%rbp)
while(n-- > 0)
139e: eb 1d jmp 13bd <memmove+0x46>
*dst++ = *src++;
13a0: 48 8b 55 f0 mov -0x10(%rbp),%rdx
13a4: 48 8d 42 01 lea 0x1(%rdx),%rax
13a8: 48 89 45 f0 mov %rax,-0x10(%rbp)
13ac: 48 8b 45 f8 mov -0x8(%rbp),%rax
13b0: 48 8d 48 01 lea 0x1(%rax),%rcx
13b4: 48 89 4d f8 mov %rcx,-0x8(%rbp)
13b8: 0f b6 12 movzbl (%rdx),%edx
13bb: 88 10 mov %dl,(%rax)
while(n-- > 0)
13bd: 8b 45 dc mov -0x24(%rbp),%eax
13c0: 8d 50 ff lea -0x1(%rax),%edx
13c3: 89 55 dc mov %edx,-0x24(%rbp)
13c6: 85 c0 test %eax,%eax
13c8: 7f d6 jg 13a0 <memmove+0x29>
return vdst;
13ca: 48 8b 45 e8 mov -0x18(%rbp),%rax
}
13ce: c9 leaveq
13cf: c3 retq
00000000000013d0 <fork>:
mov $SYS_ ## name, %rax; \
mov %rcx, %r10 ;\
syscall ;\
ret
SYSCALL(fork)
13d0: 48 c7 c0 01 00 00 00 mov $0x1,%rax
13d7: 49 89 ca mov %rcx,%r10
13da: 0f 05 syscall
13dc: c3 retq
00000000000013dd <exit>:
SYSCALL(exit)
13dd: 48 c7 c0 02 00 00 00 mov $0x2,%rax
13e4: 49 89 ca mov %rcx,%r10
13e7: 0f 05 syscall
13e9: c3 retq
00000000000013ea <wait>:
SYSCALL(wait)
13ea: 48 c7 c0 03 00 00 00 mov $0x3,%rax
13f1: 49 89 ca mov %rcx,%r10
13f4: 0f 05 syscall
13f6: c3 retq
00000000000013f7 <pipe>:
SYSCALL(pipe)
13f7: 48 c7 c0 04 00 00 00 mov $0x4,%rax
13fe: 49 89 ca mov %rcx,%r10
1401: 0f 05 syscall
1403: c3 retq
0000000000001404 <read>:
SYSCALL(read)
1404: 48 c7 c0 05 00 00 00 mov $0x5,%rax
140b: 49 89 ca mov %rcx,%r10
140e: 0f 05 syscall
1410: c3 retq
0000000000001411 <write>:
SYSCALL(write)
1411: 48 c7 c0 10 00 00 00 mov $0x10,%rax
1418: 49 89 ca mov %rcx,%r10
141b: 0f 05 syscall
141d: c3 retq
000000000000141e <close>:
SYSCALL(close)
141e: 48 c7 c0 15 00 00 00 mov $0x15,%rax
1425: 49 89 ca mov %rcx,%r10
1428: 0f 05 syscall
142a: c3 retq
000000000000142b <kill>:
SYSCALL(kill)
142b: 48 c7 c0 06 00 00 00 mov $0x6,%rax
1432: 49 89 ca mov %rcx,%r10
1435: 0f 05 syscall
1437: c3 retq
0000000000001438 <exec>:
SYSCALL(exec)
1438: 48 c7 c0 07 00 00 00 mov $0x7,%rax
143f: 49 89 ca mov %rcx,%r10
1442: 0f 05 syscall
1444: c3 retq
0000000000001445 <open>:
SYSCALL(open)
1445: 48 c7 c0 0f 00 00 00 mov $0xf,%rax
144c: 49 89 ca mov %rcx,%r10
144f: 0f 05 syscall
1451: c3 retq
0000000000001452 <mknod>:
SYSCALL(mknod)
1452: 48 c7 c0 11 00 00 00 mov $0x11,%rax
1459: 49 89 ca mov %rcx,%r10
145c: 0f 05 syscall
145e: c3 retq
000000000000145f <unlink>:
SYSCALL(unlink)
145f: 48 c7 c0 12 00 00 00 mov $0x12,%rax
1466: 49 89 ca mov %rcx,%r10
1469: 0f 05 syscall
146b: c3 retq
000000000000146c <fstat>:
SYSCALL(fstat)
146c: 48 c7 c0 08 00 00 00 mov $0x8,%rax
1473: 49 89 ca mov %rcx,%r10
1476: 0f 05 syscall
1478: c3 retq
0000000000001479 <link>:
SYSCALL(link)
1479: 48 c7 c0 13 00 00 00 mov $0x13,%rax
1480: 49 89 ca mov %rcx,%r10
1483: 0f 05 syscall
1485: c3 retq
0000000000001486 <mkdir>:
SYSCALL(mkdir)
1486: 48 c7 c0 14 00 00 00 mov $0x14,%rax
148d: 49 89 ca mov %rcx,%r10
1490: 0f 05 syscall
1492: c3 retq
0000000000001493 <chdir>:
SYSCALL(chdir)
1493: 48 c7 c0 09 00 00 00 mov $0x9,%rax
149a: 49 89 ca mov %rcx,%r10
149d: 0f 05 syscall
149f: c3 retq
00000000000014a0 <dup>:
SYSCALL(dup)
14a0: 48 c7 c0 0a 00 00 00 mov $0xa,%rax
14a7: 49 89 ca mov %rcx,%r10
14aa: 0f 05 syscall
14ac: c3 retq
00000000000014ad <getpid>:
SYSCALL(getpid)
14ad: 48 c7 c0 0b 00 00 00 mov $0xb,%rax
14b4: 49 89 ca mov %rcx,%r10
14b7: 0f 05 syscall
14b9: c3 retq
00000000000014ba <sbrk>:
SYSCALL(sbrk)
14ba: 48 c7 c0 0c 00 00 00 mov $0xc,%rax
14c1: 49 89 ca mov %rcx,%r10
14c4: 0f 05 syscall
14c6: c3 retq
00000000000014c7 <sleep>:
SYSCALL(sleep)
14c7: 48 c7 c0 0d 00 00 00 mov $0xd,%rax
14ce: 49 89 ca mov %rcx,%r10
14d1: 0f 05 syscall
14d3: c3 retq
00000000000014d4 <uptime>:
SYSCALL(uptime)
14d4: 48 c7 c0 0e 00 00 00 mov $0xe,%rax
14db: 49 89 ca mov %rcx,%r10
14de: 0f 05 syscall
14e0: c3 retq
00000000000014e1 <aread>:
SYSCALL(aread)
14e1: 48 c7 c0 16 00 00 00 mov $0x16,%rax
14e8: 49 89 ca mov %rcx,%r10
14eb: 0f 05 syscall
14ed: c3 retq
00000000000014ee <putc>:
#include <stdarg.h>
static void
putc(int fd, char c)
{
14ee: f3 0f 1e fa endbr64
14f2: 55 push %rbp
14f3: 48 89 e5 mov %rsp,%rbp
14f6: 48 83 ec 10 sub $0x10,%rsp
14fa: 89 7d fc mov %edi,-0x4(%rbp)
14fd: 89 f0 mov %esi,%eax
14ff: 88 45 f8 mov %al,-0x8(%rbp)
write(fd, &c, 1);
1502: 48 8d 4d f8 lea -0x8(%rbp),%rcx
1506: 8b 45 fc mov -0x4(%rbp),%eax
1509: ba 01 00 00 00 mov $0x1,%edx
150e: 48 89 ce mov %rcx,%rsi
1511: 89 c7 mov %eax,%edi
1513: 48 b8 11 14 00 00 00 movabs $0x1411,%rax
151a: 00 00 00
151d: ff d0 callq *%rax
}
151f: 90 nop
1520: c9 leaveq
1521: c3 retq
0000000000001522 <print_x64>:
static char digits[] = "0123456789abcdef";
static void
print_x64(int fd, addr_t x)
{
1522: f3 0f 1e fa endbr64
1526: 55 push %rbp
1527: 48 89 e5 mov %rsp,%rbp
152a: 48 83 ec 20 sub $0x20,%rsp
152e: 89 7d ec mov %edi,-0x14(%rbp)
1531: 48 89 75 e0 mov %rsi,-0x20(%rbp)
int i;
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
1535: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
153c: eb 35 jmp 1573 <print_x64+0x51>
putc(fd, digits[x >> (sizeof(addr_t) * 8 - 4)]);
153e: 48 8b 45 e0 mov -0x20(%rbp),%rax
1542: 48 c1 e8 3c shr $0x3c,%rax
1546: 48 ba 30 21 00 00 00 movabs $0x2130,%rdx
154d: 00 00 00
1550: 0f b6 04 02 movzbl (%rdx,%rax,1),%eax
1554: 0f be d0 movsbl %al,%edx
1557: 8b 45 ec mov -0x14(%rbp),%eax
155a: 89 d6 mov %edx,%esi
155c: 89 c7 mov %eax,%edi
155e: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
1565: 00 00 00
1568: ff d0 callq *%rax
for (i = 0; i < (sizeof(addr_t) * 2); i++, x <<= 4)
156a: 83 45 fc 01 addl $0x1,-0x4(%rbp)
156e: 48 c1 65 e0 04 shlq $0x4,-0x20(%rbp)
1573: 8b 45 fc mov -0x4(%rbp),%eax
1576: 83 f8 0f cmp $0xf,%eax
1579: 76 c3 jbe 153e <print_x64+0x1c>
}
157b: 90 nop
157c: 90 nop
157d: c9 leaveq
157e: c3 retq
000000000000157f <print_x32>:
static void
print_x32(int fd, uint x)
{
157f: f3 0f 1e fa endbr64
1583: 55 push %rbp
1584: 48 89 e5 mov %rsp,%rbp
1587: 48 83 ec 20 sub $0x20,%rsp
158b: 89 7d ec mov %edi,-0x14(%rbp)
158e: 89 75 e8 mov %esi,-0x18(%rbp)
int i;
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
1591: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
1598: eb 36 jmp 15d0 <print_x32+0x51>
putc(fd, digits[x >> (sizeof(uint) * 8 - 4)]);
159a: 8b 45 e8 mov -0x18(%rbp),%eax
159d: c1 e8 1c shr $0x1c,%eax
15a0: 89 c2 mov %eax,%edx
15a2: 48 b8 30 21 00 00 00 movabs $0x2130,%rax
15a9: 00 00 00
15ac: 89 d2 mov %edx,%edx
15ae: 0f b6 04 10 movzbl (%rax,%rdx,1),%eax
15b2: 0f be d0 movsbl %al,%edx
15b5: 8b 45 ec mov -0x14(%rbp),%eax
15b8: 89 d6 mov %edx,%esi
15ba: 89 c7 mov %eax,%edi
15bc: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
15c3: 00 00 00
15c6: ff d0 callq *%rax
for (i = 0; i < (sizeof(uint) * 2); i++, x <<= 4)
15c8: 83 45 fc 01 addl $0x1,-0x4(%rbp)
15cc: c1 65 e8 04 shll $0x4,-0x18(%rbp)
15d0: 8b 45 fc mov -0x4(%rbp),%eax
15d3: 83 f8 07 cmp $0x7,%eax
15d6: 76 c2 jbe 159a <print_x32+0x1b>
}
15d8: 90 nop
15d9: 90 nop
15da: c9 leaveq
15db: c3 retq
00000000000015dc <print_d>:
static void
print_d(int fd, int v)
{
15dc: f3 0f 1e fa endbr64
15e0: 55 push %rbp
15e1: 48 89 e5 mov %rsp,%rbp
15e4: 48 83 ec 30 sub $0x30,%rsp
15e8: 89 7d dc mov %edi,-0x24(%rbp)
15eb: 89 75 d8 mov %esi,-0x28(%rbp)
char buf[16];
int64 x = v;
15ee: 8b 45 d8 mov -0x28(%rbp),%eax
15f1: 48 98 cltq
15f3: 48 89 45 f8 mov %rax,-0x8(%rbp)
if (v < 0)
15f7: 83 7d d8 00 cmpl $0x0,-0x28(%rbp)
15fb: 79 04 jns 1601 <print_d+0x25>
x = -x;
15fd: 48 f7 5d f8 negq -0x8(%rbp)
int i = 0;
1601: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%rbp)
do {
buf[i++] = digits[x % 10];
1608: 48 8b 4d f8 mov -0x8(%rbp),%rcx
160c: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
1613: 66 66 66
1616: 48 89 c8 mov %rcx,%rax
1619: 48 f7 ea imul %rdx
161c: 48 c1 fa 02 sar $0x2,%rdx
1620: 48 89 c8 mov %rcx,%rax
1623: 48 c1 f8 3f sar $0x3f,%rax
1627: 48 29 c2 sub %rax,%rdx
162a: 48 89 d0 mov %rdx,%rax
162d: 48 c1 e0 02 shl $0x2,%rax
1631: 48 01 d0 add %rdx,%rax
1634: 48 01 c0 add %rax,%rax
1637: 48 29 c1 sub %rax,%rcx
163a: 48 89 ca mov %rcx,%rdx
163d: 8b 45 f4 mov -0xc(%rbp),%eax
1640: 8d 48 01 lea 0x1(%rax),%ecx
1643: 89 4d f4 mov %ecx,-0xc(%rbp)
1646: 48 b9 30 21 00 00 00 movabs $0x2130,%rcx
164d: 00 00 00
1650: 0f b6 14 11 movzbl (%rcx,%rdx,1),%edx
1654: 48 98 cltq
1656: 88 54 05 e0 mov %dl,-0x20(%rbp,%rax,1)
x /= 10;
165a: 48 8b 4d f8 mov -0x8(%rbp),%rcx
165e: 48 ba 67 66 66 66 66 movabs $0x6666666666666667,%rdx
1665: 66 66 66
1668: 48 89 c8 mov %rcx,%rax
166b: 48 f7 ea imul %rdx
166e: 48 c1 fa 02 sar $0x2,%rdx
1672: 48 89 c8 mov %rcx,%rax
1675: 48 c1 f8 3f sar $0x3f,%rax
1679: 48 29 c2 sub %rax,%rdx
167c: 48 89 d0 mov %rdx,%rax
167f: 48 89 45 f8 mov %rax,-0x8(%rbp)
} while(x != 0);
1683: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
1688: 0f 85 7a ff ff ff jne 1608 <print_d+0x2c>
if (v < 0)
168e: 83 7d d8 00 cmpl $0x0,-0x28(%rbp)
1692: 79 32 jns 16c6 <print_d+0xea>
buf[i++] = '-';
1694: 8b 45 f4 mov -0xc(%rbp),%eax
1697: 8d 50 01 lea 0x1(%rax),%edx
169a: 89 55 f4 mov %edx,-0xc(%rbp)
169d: 48 98 cltq
169f: c6 44 05 e0 2d movb $0x2d,-0x20(%rbp,%rax,1)
while (--i >= 0)
16a4: eb 20 jmp 16c6 <print_d+0xea>
putc(fd, buf[i]);
16a6: 8b 45 f4 mov -0xc(%rbp),%eax
16a9: 48 98 cltq
16ab: 0f b6 44 05 e0 movzbl -0x20(%rbp,%rax,1),%eax
16b0: 0f be d0 movsbl %al,%edx
16b3: 8b 45 dc mov -0x24(%rbp),%eax
16b6: 89 d6 mov %edx,%esi
16b8: 89 c7 mov %eax,%edi
16ba: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
16c1: 00 00 00
16c4: ff d0 callq *%rax
while (--i >= 0)
16c6: 83 6d f4 01 subl $0x1,-0xc(%rbp)
16ca: 83 7d f4 00 cmpl $0x0,-0xc(%rbp)
16ce: 79 d6 jns 16a6 <print_d+0xca>
}
16d0: 90 nop
16d1: 90 nop
16d2: c9 leaveq
16d3: c3 retq
00000000000016d4 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
16d4: f3 0f 1e fa endbr64
16d8: 55 push %rbp
16d9: 48 89 e5 mov %rsp,%rbp
16dc: 48 81 ec f0 00 00 00 sub $0xf0,%rsp
16e3: 89 bd 1c ff ff ff mov %edi,-0xe4(%rbp)
16e9: 48 89 b5 10 ff ff ff mov %rsi,-0xf0(%rbp)
16f0: 48 89 95 60 ff ff ff mov %rdx,-0xa0(%rbp)
16f7: 48 89 8d 68 ff ff ff mov %rcx,-0x98(%rbp)
16fe: 4c 89 85 70 ff ff ff mov %r8,-0x90(%rbp)
1705: 4c 89 8d 78 ff ff ff mov %r9,-0x88(%rbp)
170c: 84 c0 test %al,%al
170e: 74 20 je 1730 <printf+0x5c>
1710: 0f 29 45 80 movaps %xmm0,-0x80(%rbp)
1714: 0f 29 4d 90 movaps %xmm1,-0x70(%rbp)
1718: 0f 29 55 a0 movaps %xmm2,-0x60(%rbp)
171c: 0f 29 5d b0 movaps %xmm3,-0x50(%rbp)
1720: 0f 29 65 c0 movaps %xmm4,-0x40(%rbp)
1724: 0f 29 6d d0 movaps %xmm5,-0x30(%rbp)
1728: 0f 29 75 e0 movaps %xmm6,-0x20(%rbp)
172c: 0f 29 7d f0 movaps %xmm7,-0x10(%rbp)
va_list ap;
int i, c;
char *s;
va_start(ap, fmt);
1730: c7 85 20 ff ff ff 10 movl $0x10,-0xe0(%rbp)
1737: 00 00 00
173a: c7 85 24 ff ff ff 30 movl $0x30,-0xdc(%rbp)
1741: 00 00 00
1744: 48 8d 45 10 lea 0x10(%rbp),%rax
1748: 48 89 85 28 ff ff ff mov %rax,-0xd8(%rbp)
174f: 48 8d 85 50 ff ff ff lea -0xb0(%rbp),%rax
1756: 48 89 85 30 ff ff ff mov %rax,-0xd0(%rbp)
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
175d: c7 85 4c ff ff ff 00 movl $0x0,-0xb4(%rbp)
1764: 00 00 00
1767: e9 41 03 00 00 jmpq 1aad <printf+0x3d9>
if (c != '%') {
176c: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
1773: 74 24 je 1799 <printf+0xc5>
putc(fd, c);
1775: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
177b: 0f be d0 movsbl %al,%edx
177e: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1784: 89 d6 mov %edx,%esi
1786: 89 c7 mov %eax,%edi
1788: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
178f: 00 00 00
1792: ff d0 callq *%rax
continue;
1794: e9 0d 03 00 00 jmpq 1aa6 <printf+0x3d2>
}
c = fmt[++i] & 0xff;
1799: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
17a0: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
17a6: 48 63 d0 movslq %eax,%rdx
17a9: 48 8b 85 10 ff ff ff mov -0xf0(%rbp),%rax
17b0: 48 01 d0 add %rdx,%rax
17b3: 0f b6 00 movzbl (%rax),%eax
17b6: 0f be c0 movsbl %al,%eax
17b9: 25 ff 00 00 00 and $0xff,%eax
17be: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
if (c == 0)
17c4: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
17cb: 0f 84 0f 03 00 00 je 1ae0 <printf+0x40c>
break;
switch(c) {
17d1: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
17d8: 0f 84 74 02 00 00 je 1a52 <printf+0x37e>
17de: 83 bd 3c ff ff ff 25 cmpl $0x25,-0xc4(%rbp)
17e5: 0f 8c 82 02 00 00 jl 1a6d <printf+0x399>
17eb: 83 bd 3c ff ff ff 78 cmpl $0x78,-0xc4(%rbp)
17f2: 0f 8f 75 02 00 00 jg 1a6d <printf+0x399>
17f8: 83 bd 3c ff ff ff 63 cmpl $0x63,-0xc4(%rbp)
17ff: 0f 8c 68 02 00 00 jl 1a6d <printf+0x399>
1805: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
180b: 83 e8 63 sub $0x63,%eax
180e: 83 f8 15 cmp $0x15,%eax
1811: 0f 87 56 02 00 00 ja 1a6d <printf+0x399>
1817: 89 c0 mov %eax,%eax
1819: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx
1820: 00
1821: 48 b8 08 1e 00 00 00 movabs $0x1e08,%rax
1828: 00 00 00
182b: 48 01 d0 add %rdx,%rax
182e: 48 8b 00 mov (%rax),%rax
1831: 3e ff e0 notrack jmpq *%rax
case 'c':
putc(fd, va_arg(ap, int));
1834: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
183a: 83 f8 2f cmp $0x2f,%eax
183d: 77 23 ja 1862 <printf+0x18e>
183f: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
1846: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
184c: 89 d2 mov %edx,%edx
184e: 48 01 d0 add %rdx,%rax
1851: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1857: 83 c2 08 add $0x8,%edx
185a: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
1860: eb 12 jmp 1874 <printf+0x1a0>
1862: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
1869: 48 8d 50 08 lea 0x8(%rax),%rdx
186d: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
1874: 8b 00 mov (%rax),%eax
1876: 0f be d0 movsbl %al,%edx
1879: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
187f: 89 d6 mov %edx,%esi
1881: 89 c7 mov %eax,%edi
1883: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
188a: 00 00 00
188d: ff d0 callq *%rax
break;
188f: e9 12 02 00 00 jmpq 1aa6 <printf+0x3d2>
case 'd':
print_d(fd, va_arg(ap, int));
1894: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
189a: 83 f8 2f cmp $0x2f,%eax
189d: 77 23 ja 18c2 <printf+0x1ee>
189f: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
18a6: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
18ac: 89 d2 mov %edx,%edx
18ae: 48 01 d0 add %rdx,%rax
18b1: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
18b7: 83 c2 08 add $0x8,%edx
18ba: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
18c0: eb 12 jmp 18d4 <printf+0x200>
18c2: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
18c9: 48 8d 50 08 lea 0x8(%rax),%rdx
18cd: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
18d4: 8b 10 mov (%rax),%edx
18d6: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
18dc: 89 d6 mov %edx,%esi
18de: 89 c7 mov %eax,%edi
18e0: 48 b8 dc 15 00 00 00 movabs $0x15dc,%rax
18e7: 00 00 00
18ea: ff d0 callq *%rax
break;
18ec: e9 b5 01 00 00 jmpq 1aa6 <printf+0x3d2>
case 'x':
print_x32(fd, va_arg(ap, uint));
18f1: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
18f7: 83 f8 2f cmp $0x2f,%eax
18fa: 77 23 ja 191f <printf+0x24b>
18fc: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
1903: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1909: 89 d2 mov %edx,%edx
190b: 48 01 d0 add %rdx,%rax
190e: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1914: 83 c2 08 add $0x8,%edx
1917: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
191d: eb 12 jmp 1931 <printf+0x25d>
191f: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
1926: 48 8d 50 08 lea 0x8(%rax),%rdx
192a: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
1931: 8b 10 mov (%rax),%edx
1933: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1939: 89 d6 mov %edx,%esi
193b: 89 c7 mov %eax,%edi
193d: 48 b8 7f 15 00 00 00 movabs $0x157f,%rax
1944: 00 00 00
1947: ff d0 callq *%rax
break;
1949: e9 58 01 00 00 jmpq 1aa6 <printf+0x3d2>
case 'p':
print_x64(fd, va_arg(ap, addr_t));
194e: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
1954: 83 f8 2f cmp $0x2f,%eax
1957: 77 23 ja 197c <printf+0x2a8>
1959: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
1960: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1966: 89 d2 mov %edx,%edx
1968: 48 01 d0 add %rdx,%rax
196b: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
1971: 83 c2 08 add $0x8,%edx
1974: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
197a: eb 12 jmp 198e <printf+0x2ba>
197c: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
1983: 48 8d 50 08 lea 0x8(%rax),%rdx
1987: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
198e: 48 8b 10 mov (%rax),%rdx
1991: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1997: 48 89 d6 mov %rdx,%rsi
199a: 89 c7 mov %eax,%edi
199c: 48 b8 22 15 00 00 00 movabs $0x1522,%rax
19a3: 00 00 00
19a6: ff d0 callq *%rax
break;
19a8: e9 f9 00 00 00 jmpq 1aa6 <printf+0x3d2>
case 's':
if ((s = va_arg(ap, char*)) == 0)
19ad: 8b 85 20 ff ff ff mov -0xe0(%rbp),%eax
19b3: 83 f8 2f cmp $0x2f,%eax
19b6: 77 23 ja 19db <printf+0x307>
19b8: 48 8b 85 30 ff ff ff mov -0xd0(%rbp),%rax
19bf: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
19c5: 89 d2 mov %edx,%edx
19c7: 48 01 d0 add %rdx,%rax
19ca: 8b 95 20 ff ff ff mov -0xe0(%rbp),%edx
19d0: 83 c2 08 add $0x8,%edx
19d3: 89 95 20 ff ff ff mov %edx,-0xe0(%rbp)
19d9: eb 12 jmp 19ed <printf+0x319>
19db: 48 8b 85 28 ff ff ff mov -0xd8(%rbp),%rax
19e2: 48 8d 50 08 lea 0x8(%rax),%rdx
19e6: 48 89 95 28 ff ff ff mov %rdx,-0xd8(%rbp)
19ed: 48 8b 00 mov (%rax),%rax
19f0: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
19f7: 48 83 bd 40 ff ff ff cmpq $0x0,-0xc0(%rbp)
19fe: 00
19ff: 75 41 jne 1a42 <printf+0x36e>
s = "(null)";
1a01: 48 b8 00 1e 00 00 00 movabs $0x1e00,%rax
1a08: 00 00 00
1a0b: 48 89 85 40 ff ff ff mov %rax,-0xc0(%rbp)
while (*s)
1a12: eb 2e jmp 1a42 <printf+0x36e>
putc(fd, *(s++));
1a14: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
1a1b: 48 8d 50 01 lea 0x1(%rax),%rdx
1a1f: 48 89 95 40 ff ff ff mov %rdx,-0xc0(%rbp)
1a26: 0f b6 00 movzbl (%rax),%eax
1a29: 0f be d0 movsbl %al,%edx
1a2c: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a32: 89 d6 mov %edx,%esi
1a34: 89 c7 mov %eax,%edi
1a36: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
1a3d: 00 00 00
1a40: ff d0 callq *%rax
while (*s)
1a42: 48 8b 85 40 ff ff ff mov -0xc0(%rbp),%rax
1a49: 0f b6 00 movzbl (%rax),%eax
1a4c: 84 c0 test %al,%al
1a4e: 75 c4 jne 1a14 <printf+0x340>
break;
1a50: eb 54 jmp 1aa6 <printf+0x3d2>
case '%':
putc(fd, '%');
1a52: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a58: be 25 00 00 00 mov $0x25,%esi
1a5d: 89 c7 mov %eax,%edi
1a5f: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
1a66: 00 00 00
1a69: ff d0 callq *%rax
break;
1a6b: eb 39 jmp 1aa6 <printf+0x3d2>
default:
// Print unknown % sequence to draw attention.
putc(fd, '%');
1a6d: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a73: be 25 00 00 00 mov $0x25,%esi
1a78: 89 c7 mov %eax,%edi
1a7a: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
1a81: 00 00 00
1a84: ff d0 callq *%rax
putc(fd, c);
1a86: 8b 85 3c ff ff ff mov -0xc4(%rbp),%eax
1a8c: 0f be d0 movsbl %al,%edx
1a8f: 8b 85 1c ff ff ff mov -0xe4(%rbp),%eax
1a95: 89 d6 mov %edx,%esi
1a97: 89 c7 mov %eax,%edi
1a99: 48 b8 ee 14 00 00 00 movabs $0x14ee,%rax
1aa0: 00 00 00
1aa3: ff d0 callq *%rax
break;
1aa5: 90 nop
for (i = 0; (c = fmt[i] & 0xff) != 0; i++) {
1aa6: 83 85 4c ff ff ff 01 addl $0x1,-0xb4(%rbp)
1aad: 8b 85 4c ff ff ff mov -0xb4(%rbp),%eax
1ab3: 48 63 d0 movslq %eax,%rdx
1ab6: 48 8b 85 10 ff ff ff mov -0xf0(%rbp),%rax
1abd: 48 01 d0 add %rdx,%rax
1ac0: 0f b6 00 movzbl (%rax),%eax
1ac3: 0f be c0 movsbl %al,%eax
1ac6: 25 ff 00 00 00 and $0xff,%eax
1acb: 89 85 3c ff ff ff mov %eax,-0xc4(%rbp)
1ad1: 83 bd 3c ff ff ff 00 cmpl $0x0,-0xc4(%rbp)
1ad8: 0f 85 8e fc ff ff jne 176c <printf+0x98>
}
}
}
1ade: eb 01 jmp 1ae1 <printf+0x40d>
break;
1ae0: 90 nop
}
1ae1: 90 nop
1ae2: c9 leaveq
1ae3: c3 retq
0000000000001ae4 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
1ae4: f3 0f 1e fa endbr64
1ae8: 55 push %rbp
1ae9: 48 89 e5 mov %rsp,%rbp
1aec: 48 83 ec 18 sub $0x18,%rsp
1af0: 48 89 7d e8 mov %rdi,-0x18(%rbp)
Header *bp, *p;
bp = (Header*)ap - 1;
1af4: 48 8b 45 e8 mov -0x18(%rbp),%rax
1af8: 48 83 e8 10 sub $0x10,%rax
1afc: 48 89 45 f0 mov %rax,-0x10(%rbp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
1b00: 48 b8 60 21 00 00 00 movabs $0x2160,%rax
1b07: 00 00 00
1b0a: 48 8b 00 mov (%rax),%rax
1b0d: 48 89 45 f8 mov %rax,-0x8(%rbp)
1b11: eb 2f jmp 1b42 <free+0x5e>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
1b13: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b17: 48 8b 00 mov (%rax),%rax
1b1a: 48 39 45 f8 cmp %rax,-0x8(%rbp)
1b1e: 72 17 jb 1b37 <free+0x53>
1b20: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b24: 48 3b 45 f8 cmp -0x8(%rbp),%rax
1b28: 77 2f ja 1b59 <free+0x75>
1b2a: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b2e: 48 8b 00 mov (%rax),%rax
1b31: 48 39 45 f0 cmp %rax,-0x10(%rbp)
1b35: 72 22 jb 1b59 <free+0x75>
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
1b37: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b3b: 48 8b 00 mov (%rax),%rax
1b3e: 48 89 45 f8 mov %rax,-0x8(%rbp)
1b42: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b46: 48 3b 45 f8 cmp -0x8(%rbp),%rax
1b4a: 76 c7 jbe 1b13 <free+0x2f>
1b4c: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b50: 48 8b 00 mov (%rax),%rax
1b53: 48 39 45 f0 cmp %rax,-0x10(%rbp)
1b57: 73 ba jae 1b13 <free+0x2f>
break;
if(bp + bp->s.size == p->s.ptr){
1b59: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b5d: 8b 40 08 mov 0x8(%rax),%eax
1b60: 89 c0 mov %eax,%eax
1b62: 48 c1 e0 04 shl $0x4,%rax
1b66: 48 89 c2 mov %rax,%rdx
1b69: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b6d: 48 01 c2 add %rax,%rdx
1b70: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b74: 48 8b 00 mov (%rax),%rax
1b77: 48 39 c2 cmp %rax,%rdx
1b7a: 75 2d jne 1ba9 <free+0xc5>
bp->s.size += p->s.ptr->s.size;
1b7c: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b80: 8b 50 08 mov 0x8(%rax),%edx
1b83: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b87: 48 8b 00 mov (%rax),%rax
1b8a: 8b 40 08 mov 0x8(%rax),%eax
1b8d: 01 c2 add %eax,%edx
1b8f: 48 8b 45 f0 mov -0x10(%rbp),%rax
1b93: 89 50 08 mov %edx,0x8(%rax)
bp->s.ptr = p->s.ptr->s.ptr;
1b96: 48 8b 45 f8 mov -0x8(%rbp),%rax
1b9a: 48 8b 00 mov (%rax),%rax
1b9d: 48 8b 10 mov (%rax),%rdx
1ba0: 48 8b 45 f0 mov -0x10(%rbp),%rax
1ba4: 48 89 10 mov %rdx,(%rax)
1ba7: eb 0e jmp 1bb7 <free+0xd3>
} else
bp->s.ptr = p->s.ptr;
1ba9: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bad: 48 8b 10 mov (%rax),%rdx
1bb0: 48 8b 45 f0 mov -0x10(%rbp),%rax
1bb4: 48 89 10 mov %rdx,(%rax)
if(p + p->s.size == bp){
1bb7: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bbb: 8b 40 08 mov 0x8(%rax),%eax
1bbe: 89 c0 mov %eax,%eax
1bc0: 48 c1 e0 04 shl $0x4,%rax
1bc4: 48 89 c2 mov %rax,%rdx
1bc7: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bcb: 48 01 d0 add %rdx,%rax
1bce: 48 39 45 f0 cmp %rax,-0x10(%rbp)
1bd2: 75 27 jne 1bfb <free+0x117>
p->s.size += bp->s.size;
1bd4: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bd8: 8b 50 08 mov 0x8(%rax),%edx
1bdb: 48 8b 45 f0 mov -0x10(%rbp),%rax
1bdf: 8b 40 08 mov 0x8(%rax),%eax
1be2: 01 c2 add %eax,%edx
1be4: 48 8b 45 f8 mov -0x8(%rbp),%rax
1be8: 89 50 08 mov %edx,0x8(%rax)
p->s.ptr = bp->s.ptr;
1beb: 48 8b 45 f0 mov -0x10(%rbp),%rax
1bef: 48 8b 10 mov (%rax),%rdx
1bf2: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bf6: 48 89 10 mov %rdx,(%rax)
1bf9: eb 0b jmp 1c06 <free+0x122>
} else
p->s.ptr = bp;
1bfb: 48 8b 45 f8 mov -0x8(%rbp),%rax
1bff: 48 8b 55 f0 mov -0x10(%rbp),%rdx
1c03: 48 89 10 mov %rdx,(%rax)
freep = p;
1c06: 48 ba 60 21 00 00 00 movabs $0x2160,%rdx
1c0d: 00 00 00
1c10: 48 8b 45 f8 mov -0x8(%rbp),%rax
1c14: 48 89 02 mov %rax,(%rdx)
}
1c17: 90 nop
1c18: c9 leaveq
1c19: c3 retq
0000000000001c1a <morecore>:
static Header*
morecore(uint nu)
{
1c1a: f3 0f 1e fa endbr64
1c1e: 55 push %rbp
1c1f: 48 89 e5 mov %rsp,%rbp
1c22: 48 83 ec 20 sub $0x20,%rsp
1c26: 89 7d ec mov %edi,-0x14(%rbp)
char *p;
Header *hp;
if(nu < 4096)
1c29: 81 7d ec ff 0f 00 00 cmpl $0xfff,-0x14(%rbp)
1c30: 77 07 ja 1c39 <morecore+0x1f>
nu = 4096;
1c32: c7 45 ec 00 10 00 00 movl $0x1000,-0x14(%rbp)
p = sbrk(nu * sizeof(Header));
1c39: 8b 45 ec mov -0x14(%rbp),%eax
1c3c: 48 c1 e0 04 shl $0x4,%rax
1c40: 48 89 c7 mov %rax,%rdi
1c43: 48 b8 ba 14 00 00 00 movabs $0x14ba,%rax
1c4a: 00 00 00
1c4d: ff d0 callq *%rax
1c4f: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p == (char*)-1)
1c53: 48 83 7d f8 ff cmpq $0xffffffffffffffff,-0x8(%rbp)
1c58: 75 07 jne 1c61 <morecore+0x47>
return 0;
1c5a: b8 00 00 00 00 mov $0x0,%eax
1c5f: eb 36 jmp 1c97 <morecore+0x7d>
hp = (Header*)p;
1c61: 48 8b 45 f8 mov -0x8(%rbp),%rax
1c65: 48 89 45 f0 mov %rax,-0x10(%rbp)
hp->s.size = nu;
1c69: 48 8b 45 f0 mov -0x10(%rbp),%rax
1c6d: 8b 55 ec mov -0x14(%rbp),%edx
1c70: 89 50 08 mov %edx,0x8(%rax)
free((void*)(hp + 1));
1c73: 48 8b 45 f0 mov -0x10(%rbp),%rax
1c77: 48 83 c0 10 add $0x10,%rax
1c7b: 48 89 c7 mov %rax,%rdi
1c7e: 48 b8 e4 1a 00 00 00 movabs $0x1ae4,%rax
1c85: 00 00 00
1c88: ff d0 callq *%rax
return freep;
1c8a: 48 b8 60 21 00 00 00 movabs $0x2160,%rax
1c91: 00 00 00
1c94: 48 8b 00 mov (%rax),%rax
}
1c97: c9 leaveq
1c98: c3 retq
0000000000001c99 <malloc>:
void*
malloc(uint nbytes)
{
1c99: f3 0f 1e fa endbr64
1c9d: 55 push %rbp
1c9e: 48 89 e5 mov %rsp,%rbp
1ca1: 48 83 ec 30 sub $0x30,%rsp
1ca5: 89 7d dc mov %edi,-0x24(%rbp)
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
1ca8: 8b 45 dc mov -0x24(%rbp),%eax
1cab: 48 83 c0 0f add $0xf,%rax
1caf: 48 c1 e8 04 shr $0x4,%rax
1cb3: 83 c0 01 add $0x1,%eax
1cb6: 89 45 ec mov %eax,-0x14(%rbp)
if((prevp = freep) == 0){
1cb9: 48 b8 60 21 00 00 00 movabs $0x2160,%rax
1cc0: 00 00 00
1cc3: 48 8b 00 mov (%rax),%rax
1cc6: 48 89 45 f0 mov %rax,-0x10(%rbp)
1cca: 48 83 7d f0 00 cmpq $0x0,-0x10(%rbp)
1ccf: 75 4a jne 1d1b <malloc+0x82>
base.s.ptr = freep = prevp = &base;
1cd1: 48 b8 50 21 00 00 00 movabs $0x2150,%rax
1cd8: 00 00 00
1cdb: 48 89 45 f0 mov %rax,-0x10(%rbp)
1cdf: 48 ba 60 21 00 00 00 movabs $0x2160,%rdx
1ce6: 00 00 00
1ce9: 48 8b 45 f0 mov -0x10(%rbp),%rax
1ced: 48 89 02 mov %rax,(%rdx)
1cf0: 48 b8 60 21 00 00 00 movabs $0x2160,%rax
1cf7: 00 00 00
1cfa: 48 8b 00 mov (%rax),%rax
1cfd: 48 ba 50 21 00 00 00 movabs $0x2150,%rdx
1d04: 00 00 00
1d07: 48 89 02 mov %rax,(%rdx)
base.s.size = 0;
1d0a: 48 b8 50 21 00 00 00 movabs $0x2150,%rax
1d11: 00 00 00
1d14: c7 40 08 00 00 00 00 movl $0x0,0x8(%rax)
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
1d1b: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d1f: 48 8b 00 mov (%rax),%rax
1d22: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p->s.size >= nunits){
1d26: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d2a: 8b 40 08 mov 0x8(%rax),%eax
1d2d: 39 45 ec cmp %eax,-0x14(%rbp)
1d30: 77 65 ja 1d97 <malloc+0xfe>
if(p->s.size == nunits)
1d32: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d36: 8b 40 08 mov 0x8(%rax),%eax
1d39: 39 45 ec cmp %eax,-0x14(%rbp)
1d3c: 75 10 jne 1d4e <malloc+0xb5>
prevp->s.ptr = p->s.ptr;
1d3e: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d42: 48 8b 10 mov (%rax),%rdx
1d45: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d49: 48 89 10 mov %rdx,(%rax)
1d4c: eb 2e jmp 1d7c <malloc+0xe3>
else {
p->s.size -= nunits;
1d4e: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d52: 8b 40 08 mov 0x8(%rax),%eax
1d55: 2b 45 ec sub -0x14(%rbp),%eax
1d58: 89 c2 mov %eax,%edx
1d5a: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d5e: 89 50 08 mov %edx,0x8(%rax)
p += p->s.size;
1d61: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d65: 8b 40 08 mov 0x8(%rax),%eax
1d68: 89 c0 mov %eax,%eax
1d6a: 48 c1 e0 04 shl $0x4,%rax
1d6e: 48 01 45 f8 add %rax,-0x8(%rbp)
p->s.size = nunits;
1d72: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d76: 8b 55 ec mov -0x14(%rbp),%edx
1d79: 89 50 08 mov %edx,0x8(%rax)
}
freep = prevp;
1d7c: 48 ba 60 21 00 00 00 movabs $0x2160,%rdx
1d83: 00 00 00
1d86: 48 8b 45 f0 mov -0x10(%rbp),%rax
1d8a: 48 89 02 mov %rax,(%rdx)
return (void*)(p + 1);
1d8d: 48 8b 45 f8 mov -0x8(%rbp),%rax
1d91: 48 83 c0 10 add $0x10,%rax
1d95: eb 4e jmp 1de5 <malloc+0x14c>
}
if(p == freep)
1d97: 48 b8 60 21 00 00 00 movabs $0x2160,%rax
1d9e: 00 00 00
1da1: 48 8b 00 mov (%rax),%rax
1da4: 48 39 45 f8 cmp %rax,-0x8(%rbp)
1da8: 75 23 jne 1dcd <malloc+0x134>
if((p = morecore(nunits)) == 0)
1daa: 8b 45 ec mov -0x14(%rbp),%eax
1dad: 89 c7 mov %eax,%edi
1daf: 48 b8 1a 1c 00 00 00 movabs $0x1c1a,%rax
1db6: 00 00 00
1db9: ff d0 callq *%rax
1dbb: 48 89 45 f8 mov %rax,-0x8(%rbp)
1dbf: 48 83 7d f8 00 cmpq $0x0,-0x8(%rbp)
1dc4: 75 07 jne 1dcd <malloc+0x134>
return 0;
1dc6: b8 00 00 00 00 mov $0x0,%eax
1dcb: eb 18 jmp 1de5 <malloc+0x14c>
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
1dcd: 48 8b 45 f8 mov -0x8(%rbp),%rax
1dd1: 48 89 45 f0 mov %rax,-0x10(%rbp)
1dd5: 48 8b 45 f8 mov -0x8(%rbp),%rax
1dd9: 48 8b 00 mov (%rax),%rax
1ddc: 48 89 45 f8 mov %rax,-0x8(%rbp)
if(p->s.size >= nunits){
1de0: e9 41 ff ff ff jmpq 1d26 <malloc+0x8d>
}
}
1de5: c9 leaveq
1de6: c3 retq
|
ciphers/rc6.asm | FloydZ/Crypto-Hash | 11 | 170437 | <gh_stars>10-100
;; RC6.ASM -- Implementation of RC6 in MASM
;; (C)opyLeft 2005 by drizz
;; P2 533MHz
;; -----------------------------------------
;; RC6Init: 1463 cycles
;; RC6Encrypt: 248 cycles
;; RC6Decrypt: 226 cycles
;; -----------------------------------------
RC6Init PROTO :DWORD,:DWORD
RC6Encrypt PROTO :DWORD,:DWORD
RC6Decrypt PROTO :DWORD,:DWORD
.const
RC6ROUNDS equ 20
RC6KR equ ((RC6ROUNDS+2)*2)
RC6_P equ 0B7E15163h
RC6_Q equ 09E3779B9h
.data?
RC6_KEY dd RC6KR dup(?)
.code
; uses ecx
RC6SETUP macro A,B,kEy,_L
add A,B
add A,kEy
rol A,3
lea ecx,[A+B]
mov kEy,A
add B,A
add B,_L
rol B,cl
mov _L,B
endm
RC6Init proc pKey:DWORD,dwKeyLen:DWORD
LOCAL RC6L[8]:dword
LOCAL SaveEsi,SaveEdi,SaveEbx
shr dwKeyLen,2
mov SaveEsi,esi
mov SaveEdi,edi
mov SaveEbx,ebx
xor edx,edx
mov eax,pKey
.repeat
mov ecx,[eax][edx*4][0*4]
mov ebx,[eax][edx*4][1*4]
mov RC6L[edx*4][0*4],ecx
mov RC6L[edx*4][1*4],ebx
add edx,2
.until edx >= dwKeyLen
mov eax,RC6_P
xor edx,edx
mov edi,offset RC6_KEY
;Bugfix by Floyd
mov ecx, RC6_P
add ecx, RC6_Q
;mov ecx,RC6_P+RC6_Q
.repeat
mov [edi][edx*4][0*4],eax
mov [edi][edx*4][1*4],ecx
add edx,2
lea eax,[ecx+RC6_Q]
cmp edx,RC6KR
lea ecx,[eax+RC6_Q]
.until zero?
xor eax,eax
xor ebx,ebx
xor edx,edx
xor edi,edi
xor esi,esi
.repeat
RC6SETUP eax,ebx,RC6_KEY[edi*4][0*4],RC6L[esi*4][0*4]
RC6SETUP eax,ebx,RC6_KEY[edi*4][1*4],RC6L[esi*4][1*4]
add edx,2
add edi,2
add esi,2
cmp edi,RC6KR
sbb ecx,ecx
and edi,ecx
cmp esi,dwKeyLen
sbb ecx,ecx
and esi,ecx
.until edx >= RC6KR*3
mov eax,offset RC6_KEY
mov esi,SaveEsi
mov edi,SaveEdi
mov ebx,SaveEbx
ret
RC6Init endp
OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE
RC6ENCRND macro _I,_A,_B,_C,_D
lea eax,[_B+_B+1]
lea ecx,[_D+_D+1]
imul eax,_B
imul ecx,_D
rol eax,5
rol ecx,5
xor _A,eax
xor _C,ecx
rol _A,cl
mov cl,al
rol _C,cl
add _A,RC6_KEY[_I*4+0*4]
add _C,RC6_KEY[_I*4+1*4]
endm
RC6Encrypt proc pPlainText:DWORD,pCipherText:DWORD
push ebp
push esi
push edi
push ebx
mov eax,[esp][1*4][4*4];pPlainText
mov esi,[eax][0*4]
mov ebx,[eax][1*4]
mov edi,[eax][2*4]
mov ebp,[eax][3*4]
add ebx,RC6_KEY[0*4]
add ebp,RC6_KEY[1*4]
RC6ENCRND 02,esi,ebx,edi,ebp
RC6ENCRND 04,ebx,edi,ebp,esi
RC6ENCRND 06,edi,ebp,esi,ebx
RC6ENCRND 08,ebp,esi,ebx,edi
RC6ENCRND 10,esi,ebx,edi,ebp
RC6ENCRND 12,ebx,edi,ebp,esi
RC6ENCRND 14,edi,ebp,esi,ebx
RC6ENCRND 16,ebp,esi,ebx,edi
RC6ENCRND 18,esi,ebx,edi,ebp
RC6ENCRND 20,ebx,edi,ebp,esi
RC6ENCRND 22,edi,ebp,esi,ebx
RC6ENCRND 24,ebp,esi,ebx,edi
RC6ENCRND 26,esi,ebx,edi,ebp
RC6ENCRND 28,ebx,edi,ebp,esi
RC6ENCRND 30,edi,ebp,esi,ebx
RC6ENCRND 32,ebp,esi,ebx,edi
RC6ENCRND 34,esi,ebx,edi,ebp
RC6ENCRND 36,ebx,edi,ebp,esi
RC6ENCRND 38,edi,ebp,esi,ebx
RC6ENCRND 40,ebp,esi,ebx,edi
mov eax,[esp][2*4][4*4];pCipherText
add esi,RC6_KEY[42*4]
add edi,RC6_KEY[43*4]
mov [eax][0*4],esi
mov [eax][1*4],ebx
mov [eax][2*4],edi
mov [eax][3*4],ebp
pop ebx
pop edi
pop esi
pop ebp
ret 2*4
RC6Encrypt endp
RC6DECRND macro _I,_A,_B,_C,_D
sub _C,RC6_KEY[_I*4+1*4]
lea eax,[_D+_D+1]
sub _A,RC6_KEY[_I*4+0*4]
lea edx,[_B+_B+1]
imul eax,_D
imul edx,_B
rol eax,5
rol edx,5
mov cl,dl
ror _C,cl
mov cl,al
ror _A,cl
xor _C,eax
xor _A,edx
endm
RC6Decrypt proc pCipherText:DWORD,pPlainText:DWORD
push ebp
push esi
push edi
push ebx
mov edx,[esp][1*4][4*4];pCipherText
mov esi,[edx][0*4]
mov ebx,[edx][1*4]
mov edi,[edx][2*4]
mov ebp,[edx][3*4]
sub esi,RC6_KEY[42*4]
sub edi,RC6_KEY[43*4]
RC6DECRND 40,ebp,esi,ebx,edi
RC6DECRND 38,edi,ebp,esi,ebx
RC6DECRND 36,ebx,edi,ebp,esi
RC6DECRND 34,esi,ebx,edi,ebp
RC6DECRND 32,ebp,esi,ebx,edi
RC6DECRND 30,edi,ebp,esi,ebx
RC6DECRND 28,ebx,edi,ebp,esi
RC6DECRND 26,esi,ebx,edi,ebp
RC6DECRND 24,ebp,esi,ebx,edi
RC6DECRND 22,edi,ebp,esi,ebx
RC6DECRND 20,ebx,edi,ebp,esi
RC6DECRND 18,esi,ebx,edi,ebp
RC6DECRND 16,ebp,esi,ebx,edi
RC6DECRND 14,edi,ebp,esi,ebx
RC6DECRND 12,ebx,edi,ebp,esi
RC6DECRND 10,esi,ebx,edi,ebp
RC6DECRND 08,ebp,esi,ebx,edi
RC6DECRND 06,edi,ebp,esi,ebx
RC6DECRND 04,ebx,edi,ebp,esi
RC6DECRND 02,esi,ebx,edi,ebp
mov edx,[esp][2*4][4*4];pPlainText
sub ebp,RC6_KEY[1*4]
sub ebx,RC6_KEY[0*4]
mov [edx][0*4],esi
mov [edx][1*4],ebx
mov [edx][2*4],edi
mov [edx][3*4],ebp
pop ebx
pop edi
pop esi
pop ebp
ret 2*4
RC6Decrypt endp
OPTION PROLOGUE:PROLOGUEDEF
OPTION EPILOGUE:EPILOGUEDEF
|
pgada-database.adb | io7m/coreland-postgres-ada | 1 | 26052 | ------------------------------------------------------------------------------
-- --
-- P G A D A . D A T A B A S E --
-- --
-- B o d y --
-- --
-- Copyright (c) <NAME> 2000 --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- 1. Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- 2. 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. --
-- 3. Neither the name of <NAME> 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 SAMUEL TARDIEU 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 SAMUEL --
-- TARDIEU 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. --
-- --
------------------------------------------------------------------------------
with Ada.Unchecked_Deallocation;
with Interfaces.C.Strings;
with Interfaces.C;
package body PGAda.Database is
package ICS renames Interfaces.C.Strings;
package IC renames Interfaces.C;
use type ICS.chars_ptr;
use type IC.int;
use type PGAda.Thin.PG_Conn_Access_t;
use type PGAda.Thin.PG_Result_Access_t;
Exec_Status_Match :
constant array (Thin.Exec_Status_t) of Exec_Status_t :=
(PGAda.Thin.PGRES_EMPTY_QUERY => Empty_Query,
PGAda.Thin.PGRES_COMMAND_OK => Command_OK,
PGAda.Thin.PGRES_TUPLES_OK => Tuples_OK,
PGAda.Thin.PGRES_COPY_OUT => Copy_Out,
PGAda.Thin.PGRES_COPY_IN => Copy_In,
PGAda.Thin.PGRES_BAD_RESPONSE => Bad_Response,
PGAda.Thin.PGRES_NONFATAL_ERROR => Non_Fatal_Error,
PGAda.Thin.PGRES_FATAL_ERROR => Fatal_Error);
-----------------------
-- Local subprograms --
-----------------------
function C_String_Or_Null (S : String) return ICS.chars_ptr;
procedure Free (S : in out ICS.chars_ptr);
-- Create a C string or return Null_Ptr if the string is empty, and
-- free it if needed.
------------
-- Adjust --
------------
procedure Adjust (Result : in out Result_t) is
begin
Result.Ref_Count.all := Result.Ref_Count.all + 1;
end Adjust;
----------------------
-- C_String_Or_Null --
----------------------
function C_String_Or_Null (S : String) return ICS.chars_ptr is
begin
if S = "" then
return ICS.Null_Ptr;
else
return ICS.New_String (S);
end if;
end C_String_Or_Null;
-----------
-- Clear --
-----------
procedure Clear (Result : in out Result_t) is
begin
PGAda.Thin.PQ_Clear (Result.Actual);
Result.Actual := null;
end Clear;
--------------------
-- Command_Status --
--------------------
function Command_Status (Result : Result_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Cmd_Status (Result.Actual));
end Command_Status;
--------------------
-- Command_Tuples --
--------------------
function Command_Tuples (Result : Result_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Cmd_Tuples (Result.Actual));
end Command_Tuples;
--------
-- DB --
--------
function DB (Connection : Connection_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Db (Connection.Actual));
end DB;
-------------------
-- Error_Message --
-------------------
function Error_Message (Connection : Connection_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Error_Message (Connection.Actual));
end Error_Message;
-------------------
-- Error_Message --
-------------------
function Error_Message (Result : Result_t) return String is
begin
return Result_Error_Field
(Result => Result,
Field => PGAda.Thin.PG_DIAG_MESSAGE_PRIMARY);
end Error_Message;
----------
-- Exec --
----------
procedure Exec
(Connection : in Connection_t'Class;
Query : in String;
Result : out Result_t;
Status : out Exec_Status_t)
is
C_Query : ICS.chars_ptr := ICS.New_String (Query);
begin
Result.Actual := PGAda.Thin.PQ_Exec (Connection.Actual, C_Query);
ICS.Free (C_Query);
Status := Result_Status (Result);
end Exec;
----------
-- Exec --
----------
procedure Exec
(Connection : in Connection_t'Class;
Query : in String;
Result : out Result_t)
is
C_Query : ICS.chars_ptr := ICS.New_String (Query);
begin
Result.Actual := PGAda.Thin.PQ_Exec (Connection.Actual, C_Query);
ICS.Free (C_Query);
end Exec;
----------
-- Exec --
----------
function Exec
(Connection : Connection_t'Class;
Query : String) return Result_t
is
Result : Result_t;
begin
Exec (Connection, Query, Result);
return Result;
end Exec;
----------
-- Exec --
----------
procedure Exec
(Connection : in Connection_t'Class;
Query : in String)
is
Result : Result_t;
begin
-- Result value ignored by call
pragma Warnings (off);
Exec (Connection, Query, Result);
pragma Warnings (on);
end Exec;
----------------
-- Field_Name --
----------------
function Field_Name
(Result : Result_t;
Field_Index : Positive) return String is
begin
return ICS.Value (PGAda.Thin.PQ_F_Name (Result.Actual, IC.int (Field_Index) - 1));
end Field_Name;
--------------
-- Finalize --
--------------
procedure Finalize (Connection : in out Connection_t) is
begin
if Connection.Actual /= null then
Finish (Connection);
end if;
end Finalize;
--------------
-- Finalize --
--------------
procedure Finalize (Result : in out Result_t) is
procedure Free is
new Ada.Unchecked_Deallocation (Natural, Natural_Access_t);
begin
Result.Ref_Count.all := Result.Ref_Count.all - 1;
if Result.Ref_Count.all = 0 and then Result.Actual /= null then
Free (Result.Ref_Count);
Clear (Result);
end if;
end Finalize;
------------
-- Finish --
------------
procedure Finish (Connection : in out Connection_t) is
begin
PGAda.Thin.PQ_Finish (Connection.Actual);
Connection.Actual := null;
end Finish;
----------
-- Free --
----------
procedure Free (S : in out ICS.chars_ptr) is
begin
if S /= ICS.Null_Ptr then
ICS.Free (S);
end if;
end Free;
----------------
-- Get_Length --
----------------
function Get_Length
(Result : Result_t;
Tuple_Index : Positive;
Field_Index : Positive) return Natural is
begin
return Natural (PGAda.Thin.PQ_Get_Length
(Result.Actual, IC.int (Tuple_Index) - 1, IC.int (Field_Index) - 1));
end Get_Length;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Index : Positive) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Get_Value
(Result.Actual, IC.int (Tuple_Index) - 1, IC.int (Field_Index) - 1));
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Name : String) return String
is
C_Name : ICS.chars_ptr := ICS.New_String (Field_Name);
Ret : constant String :=
Get_Value (Result, Tuple_Index,
1 + Natural (PGAda.Thin.PQ_F_Number (Result.Actual, C_Name)));
begin
Free (C_Name);
return Ret;
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Index : Positive) return Integer is
begin
return Integer'Value (Get_Value (Result, Tuple_Index, Field_Index));
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Name : String) return Integer is
begin
return Integer'Value (Get_Value (Result, Tuple_Index, Field_Name));
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Index : Positive) return Long_Integer is
begin
return Long_Integer'Value (Get_Value (Result, Tuple_Index, Field_Index));
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Name : String) return Long_Integer is
begin
return Long_Integer'Value (Get_Value (Result, Tuple_Index, Field_Name));
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Index : Positive) return Long_Long_Integer is
begin
return Long_Long_Integer'Value
(Get_Value (Result, Tuple_Index, Field_Index));
end Get_Value;
---------------
-- Get_Value --
---------------
function Get_Value
(Result : Result_t;
Tuple_Index : Positive;
Field_Name : String) return Long_Long_Integer is
begin
return Long_Long_Integer'Value
(Get_Value (Result, Tuple_Index, Field_Name));
end Get_Value;
----------
-- Host --
----------
function Host (Connection : Connection_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Host (Connection.Actual));
end Host;
-------------
-- Is_Null --
-------------
function Is_Null
(Result : Result_t;
Tuple_Index : Positive;
Field_Index : Positive) return Boolean is
begin
return 1 = PGAda.Thin.PQ_Get_Is_Null
(Result.Actual, IC.int (Tuple_Index) - 1, IC.int (Field_Index) - 1);
end Is_Null;
----------------
-- Nbr_Fields --
----------------
function Nbr_Fields (Result : Result_t) return Natural is
begin
return Natural (PGAda.Thin.PQ_N_Fields (Result.Actual));
end Nbr_Fields;
----------------
-- Nbr_Tuples --
----------------
function Nbr_Tuples (Result : Result_t) return Natural is
begin
return Natural (PGAda.Thin.PQ_N_Tuples (Result.Actual));
end Nbr_Tuples;
----------------
-- OID_Status --
----------------
function OID_Status (Result : Result_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Oid_Status (Result.Actual));
end OID_Status;
-------------
-- Options --
-------------
function Options (Connection : Connection_t) return String is
begin
return ICS.Value (PGAda.Thin.PQ_Options (Connection.Actual));
end Options;
----------
-- Port --
----------
function Port (Connection : Connection_t) return Positive is
begin
return Positive'Value (ICS.Value (PGAda.Thin.PQ_Port (Connection.Actual)));
end Port;
-----------
-- Reset --
-----------
procedure Reset (Connection : in Connection_t) is
begin
PGAda.Thin.PQ_Reset (Connection.Actual);
end Reset;
-------------------
-- Result_Status --
-------------------
function Result_Status (Result : Result_t) return Exec_Status_t is
begin
return Exec_Status_Match (PGAda.Thin.PQ_Result_Status (Result.Actual));
end Result_Status;
------------------------
-- Result_Error_Field --
------------------------
function Result_Error_Field
(Result : Result_t;
Field : Error_Field) return String
is
C_Res : constant ICS.chars_ptr :=
PGAda.Thin.PQ_Result_Error_Field (Result.Actual, Field);
begin
if C_Res = ICS.Null_Ptr then
return "";
else
return ICS.Value (C_Res);
end if;
end Result_Error_Field;
----------------
-- Error_Code --
----------------
function Error_Code (Result : Result_t)
return PGAda.Errors.Error_Value_t is
begin
return PGAda.Errors.Error_Value
(Result_Error_Field (Result, PGAda.Thin.PG_DIAG_SQLSTATE));
end Error_Code;
------------------
-- Set_DB_Login --
------------------
procedure Set_DB_Login
(Connection : in out Connection_t;
Host : in String := "";
Port : in Natural := 0;
Options : in String := "";
TTY : in String := "";
DB_Name : in String := "";
Login : in String := "";
Password : in String := "")
is
C_Host : ICS.chars_ptr := C_String_Or_Null (Host);
C_Port : ICS.chars_ptr;
C_Options : ICS.chars_ptr := C_String_Or_Null (Options);
C_TTY : ICS.chars_ptr := C_String_Or_Null (TTY);
C_DB_Name : ICS.chars_ptr := C_String_Or_Null (DB_Name);
C_Login : ICS.chars_ptr := C_String_Or_Null (Login);
C_Password : ICS.chars_ptr := C_String_Or_Null (Password);
begin
if Port = 0 then
C_Port := ICS.Null_Ptr;
else
C_Port := ICS.New_String (Positive'Image (Port));
end if;
Connection.Actual :=
PGAda.Thin.PQ_Set_Db_Login
(C_Host,
C_Port,
C_Options,
C_TTY,
C_DB_Name,
C_Login,
C_Password);
Free (C_Host);
Free (C_Port);
Free (C_Options);
Free (C_TTY);
Free (C_DB_Name);
Free (C_Login);
Free (C_Password);
if Connection.Actual = null then
raise PG_Error;
end if;
end Set_DB_Login;
------------
-- Status --
------------
function Status (Connection : Connection_t) return Connection_Status_t is
begin
case PGAda.Thin.PQ_Status (Connection.Actual) is
when PGAda.Thin.CONNECTION_OK => return Connection_OK;
when PGAda.Thin.CONNECTION_BAD => return Connection_Bad;
end case;
end Status;
end PGAda.Database;
|
test/Fail/Sections-9.agda | cruhland/agda | 1,989 | 5583 | <filename>test/Fail/Sections-9.agda
open import Common.Prelude
⟨_⟩_ : Bool → Bool → Bool
⟨ _ ⟩_ = λ b → b
|
programs/oeis/038/A038801.asm | karttu/loda | 1 | 178323 | ; A038801: Number of primes less than 10n.
; 4,8,10,12,15,17,19,22,24,25,29,30,31,34,35,37,39,41,42,46,46,47,50,52,53,55,57,59,61,62,63,66,66,68,70,72,73,75,77,78,80,81,82,85,87,88,91,92,93,95,97,97,99,99,101,102,104,106,107,109,111,114,114,115,118,120,121,123,124,125,127,128,129,131,132,134,136,137,138,139,140,141,145,146,146,149,150,151,154,154,155,157,158,159,161,162,163,165,166,168,169,171,172,175,176,177,180,180,181,184,186,187,189,189,189,191,192,193,195,196,197,199,201,203,204,205,205,207,209,211,214,215,217,217,217,217,219,220,221,222,223,223,226,228,229,232,232,233,237,239,239,240,241,242,244,246,247,249,250,251,254,256,258,259,259,260,263,263,263,266,267,267,269,270,272,274,274,275,278,278,279,280,281,282,283,283,285,289,290,290,292,293,293,295,296,297,297,299,300,303,304,306,308,309,309,310,312,312,316,317,317,319,320,322,324,325,326,327,327,327,329,330,331,333,334,335,337,338,340,342,343,344,344,346,348,350,350,352,355,357,357,359,360,361,363,364,365,367,367,367
mul $0,5
add $0,4
cal $0,99801 ; PrimePi(2n+1), the number of primes less than or equal to 2n+1.
add $0,44
mul $0,14
mov $1,$0
sub $1,672
div $1,14
add $1,4
|
Cubical/Algebra/Ring/Base.agda | Edlyr/cubical | 0 | 13889 | <reponame>Edlyr/cubical
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Ring.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.Transport
open import Cubical.Foundations.SIP
open import Cubical.Data.Sigma
open import Cubical.Structures.Axioms
open import Cubical.Structures.Auto
open import Cubical.Structures.Macro
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
open import Cubical.Algebra.AbGroup
open import Cubical.Reflection.StrictEquiv
open Iso
private
variable
ℓ ℓ' : Level
record IsRing {R : Type ℓ}
(0r 1r : R) (_+_ _·_ : R → R → R) (-_ : R → R) : Type ℓ where
constructor isring
field
+IsAbGroup : IsAbGroup 0r _+_ -_
·IsMonoid : IsMonoid 1r _·_
dist : (x y z : R) → (x · (y + z) ≡ (x · y) + (x · z))
× ((x + y) · z ≡ (x · z) + (y · z))
-- This is in the Agda stdlib, but it's redundant
-- zero : (x : R) → (x · 0r ≡ 0r) × (0r · x ≡ 0r)
open IsAbGroup +IsAbGroup public
renaming
( assoc to +Assoc
; identity to +Identity
; lid to +Lid
; rid to +Rid
; inverse to +Inv
; invl to +Linv
; invr to +Rinv
; comm to +Comm
; isSemigroup to +IsSemigroup
; isMonoid to +IsMonoid
; isGroup to +IsGroup )
open IsMonoid ·IsMonoid public
renaming
( assoc to ·Assoc
; identity to ·Identity
; lid to ·Lid
; rid to ·Rid
; isSemigroup to ·IsSemigroup )
hiding
( is-set ) -- We only want to export one proof of this
·Rdist+ : (x y z : R) → x · (y + z) ≡ (x · y) + (x · z)
·Rdist+ x y z = dist x y z .fst
·Ldist+ : (x y z : R) → (x + y) · z ≡ (x · z) + (y · z)
·Ldist+ x y z = dist x y z .snd
record RingStr (A : Type ℓ) : Type (ℓ-suc ℓ) where
constructor ringstr
field
0r : A
1r : A
_+_ : A → A → A
_·_ : A → A → A
-_ : A → A
isRing : IsRing 0r 1r _+_ _·_ -_
infix 8 -_
infixl 7 _·_
infixl 6 _+_
open IsRing isRing public
Ring : Type (ℓ-suc ℓ)
Ring = TypeWithStr _ RingStr
isSetRing : (R : Ring {ℓ}) → isSet ⟨ R ⟩
isSetRing R = R .snd .RingStr.isRing .IsRing.·IsMonoid .IsMonoid.isSemigroup .IsSemigroup.is-set
makeIsRing : {R : Type ℓ} {0r 1r : R} {_+_ _·_ : R → R → R} { -_ : R → R}
(is-setR : isSet R)
(+-assoc : (x y z : R) → x + (y + z) ≡ (x + y) + z)
(+-rid : (x : R) → x + 0r ≡ x)
(+-rinv : (x : R) → x + (- x) ≡ 0r)
(+-comm : (x y : R) → x + y ≡ y + x)
(r+-assoc : (x y z : R) → x · (y · z) ≡ (x · y) · z)
(·-rid : (x : R) → x · 1r ≡ x)
(·-lid : (x : R) → 1r · x ≡ x)
(·-rdist-+ : (x y z : R) → x · (y + z) ≡ (x · y) + (x · z))
(·-ldist-+ : (x y z : R) → (x + y) · z ≡ (x · z) + (y · z))
→ IsRing 0r 1r _+_ _·_ -_
makeIsRing is-setR assoc +-rid +-rinv +-comm ·-assoc ·-rid ·-lid ·-rdist-+ ·-ldist-+ =
isring (makeIsAbGroup is-setR assoc +-rid +-rinv +-comm)
(makeIsMonoid is-setR ·-assoc ·-rid ·-lid)
λ x y z → ·-rdist-+ x y z , ·-ldist-+ x y z
makeRing : {R : Type ℓ} (0r 1r : R) (_+_ _·_ : R → R → R) (-_ : R → R)
(is-setR : isSet R)
(+-assoc : (x y z : R) → x + (y + z) ≡ (x + y) + z)
(+-rid : (x : R) → x + 0r ≡ x)
(+-rinv : (x : R) → x + (- x) ≡ 0r)
(+-comm : (x y : R) → x + y ≡ y + x)
(+-assoc : (x y z : R) → x · (y · z) ≡ (x · y) · z)
(·-rid : (x : R) → x · 1r ≡ x)
(·-lid : (x : R) → 1r · x ≡ x)
(·-rdist-+ : (x y z : R) → x · (y + z) ≡ (x · y) + (x · z))
(·-ldist-+ : (x y z : R) → (x + y) · z ≡ (x · z) + (y · z))
→ Ring
makeRing 0r 1r _+_ _·_ -_ is-setR assoc +-rid +-rinv +-comm ·-assoc ·-rid ·-lid ·-rdist-+ ·-ldist-+ =
_ , ringstr 0r 1r _+_ _·_ -_
(makeIsRing is-setR assoc +-rid +-rinv +-comm
·-assoc ·-rid ·-lid ·-rdist-+ ·-ldist-+ )
record RingEquiv (R : Ring {ℓ}) (S : Ring {ℓ'}) (e : ⟨ R ⟩ ≃ ⟨ S ⟩) : Type (ℓ-max ℓ ℓ') where
constructor ringequiv
private
module R = RingStr (snd R)
module S = RingStr (snd S)
field
pres1 : equivFun e R.1r ≡ S.1r
isHom+ : (x y : ⟨ R ⟩) → equivFun e (x R.+ y) ≡ equivFun e x S.+ equivFun e y
isHom· : (x y : ⟨ R ⟩) → equivFun e (x R.· y) ≡ equivFun e x S.· equivFun e y
record RingHom (R S : Ring {ℓ}) : Type ℓ where
constructor ringhom
private
module R = RingStr (snd R)
module S = RingStr (snd S)
field
f : ⟨ R ⟩ → ⟨ S ⟩
pres1 : f R.1r ≡ S.1r
isHom+ : (x y : ⟨ R ⟩) → f (x R.+ y) ≡ f x S.+ f y
isHom· : (x y : ⟨ R ⟩) → f (x R.· y) ≡ f x S.· f y
_$_ : {R S : Ring {ℓ}} → (φ : RingHom R S) → (x : ⟨ R ⟩) → ⟨ S ⟩
φ $ x = RingHom.f φ x
module RingΣTheory {ℓ} where
RawRingStructure = λ (X : Type ℓ) → (X → X → X) × X × (X → X → X)
RawRingEquivStr = AutoEquivStr RawRingStructure
rawRingUnivalentStr : UnivalentStr _ RawRingEquivStr
rawRingUnivalentStr = autoUnivalentStr RawRingStructure
RingAxioms : (R : Type ℓ) (s : RawRingStructure R) → Type ℓ
RingAxioms R (_+_ , 1r , _·_) =
AbGroupΣTheory.AbGroupAxioms R _+_
× IsMonoid 1r _·_
× ((x y z : R) → (x · (y + z) ≡ (x · y) + (x · z)) × ((x + y) · z ≡ (x · z) + (y · z)))
RingStructure : Type ℓ → Type ℓ
RingStructure = AxiomsStructure RawRingStructure RingAxioms
RingΣ : Type (ℓ-suc ℓ)
RingΣ = TypeWithStr ℓ RingStructure
RingEquivStr : StrEquiv RingStructure ℓ
RingEquivStr = AxiomsEquivStr RawRingEquivStr RingAxioms
isPropRingAxioms : (R : Type ℓ) (s : RawRingStructure R) → isProp (RingAxioms R s)
isPropRingAxioms R (_+_ , 1r , _·_) =
isProp× (AbGroupΣTheory.isPropAbGroupAxioms R _+_)
(isPropΣ (isPropIsMonoid 1r _·_)
λ R → isPropΠ3 λ _ _ _ →
isProp× (IsSemigroup.is-set (R .IsMonoid.isSemigroup) _ _)
(IsSemigroup.is-set (R .IsMonoid.isSemigroup) _ _))
Ring→RingΣ : Ring → RingΣ
Ring→RingΣ (R , ringstr 0r 1r _+_ _·_ -_ (isring +-isAbelianGroup ·-isMonoid dist)) =
( R
, (_+_ , 1r , _·_)
, AbGroupΣTheory.AbGroup→AbGroupΣ (_ , abgroupstr _ _ _ +-isAbelianGroup) .snd .snd
, ·-isMonoid , dist
)
RingΣ→Ring : RingΣ → Ring
RingΣ→Ring (_ , (y1 , y2 , y3) , z , w1 , w2) =
_ , ringstr _ y2 y1 y3 _
(isring (AbGroupΣTheory.AbGroupΣ→AbGroup (_ , _ , z ) .snd .AbGroupStr.isAbGroup)
w1 w2)
RingIsoRingΣ : Iso Ring RingΣ
RingIsoRingΣ = iso Ring→RingΣ RingΣ→Ring (λ _ → refl) (λ _ → refl)
ringUnivalentStr : UnivalentStr RingStructure RingEquivStr
ringUnivalentStr = axiomsUnivalentStr _ isPropRingAxioms rawRingUnivalentStr
RingΣPath : (R S : RingΣ) → (R ≃[ RingEquivStr ] S) ≃ (R ≡ S)
RingΣPath = SIP ringUnivalentStr
RingEquivΣ : (R S : Ring) → Type ℓ
RingEquivΣ R S = Ring→RingΣ R ≃[ RingEquivStr ] Ring→RingΣ S
RingIsoΣPath : {R S : Ring} → Iso (Σ[ e ∈ ⟨ R ⟩ ≃ ⟨ S ⟩ ] RingEquiv R S e) (RingEquivΣ R S)
fun RingIsoΣPath (e , ringequiv h1 h2 h3) = e , h2 , h1 , h3
inv RingIsoΣPath (e , h1 , h2 , h3) = e , ringequiv h2 h1 h3
rightInv RingIsoΣPath _ = refl
leftInv RingIsoΣPath _ = refl
RingPath : (R S : Ring) → (Σ[ e ∈ ⟨ R ⟩ ≃ ⟨ S ⟩ ] RingEquiv R S e) ≃ (R ≡ S)
RingPath R S =
Σ[ e ∈ ⟨ R ⟩ ≃ ⟨ S ⟩ ] RingEquiv R S e ≃⟨ strictIsoToEquiv RingIsoΣPath ⟩
RingEquivΣ R S ≃⟨ RingΣPath _ _ ⟩
Ring→RingΣ R ≡ Ring→RingΣ S ≃⟨ isoToEquiv (invIso (congIso RingIsoRingΣ)) ⟩
R ≡ S ■
RingPath : (R S : Ring {ℓ}) → (Σ[ e ∈ ⟨ R ⟩ ≃ ⟨ S ⟩ ] RingEquiv R S e) ≃ (R ≡ S)
RingPath = RingΣTheory.RingPath
isPropIsRing : {R : Type ℓ} (0r 1r : R) (_+_ _·_ : R → R → R) (-_ : R → R)
→ isProp (IsRing 0r 1r _+_ _·_ -_)
isPropIsRing 0r 1r _+_ _·_ -_ (isring RG RM RD) (isring SG SM SD) =
λ i → isring (isPropIsAbGroup _ _ _ RG SG i)
(isPropIsMonoid _ _ RM SM i)
(isPropDistr RD SD i)
where
isSetR : isSet _
isSetR = RM .IsMonoid.isSemigroup .IsSemigroup.is-set
isPropDistr : isProp ((x y z : _) → ((x · (y + z)) ≡ ((x · y) + (x · z)))
× (((x + y) · z) ≡ ((x · z) + (y · z))))
isPropDistr = isPropΠ3 λ _ _ _ → isProp× (isSetR _ _) (isSetR _ _)
-- Rings have an abelian group and a monoid
Ring→AbGroup : Ring {ℓ} → AbGroup {ℓ}
Ring→AbGroup (A , ringstr _ _ _ _ _ R) = A , abgroupstr _ _ _ (IsRing.+IsAbGroup R)
Ring→Monoid : Ring {ℓ} → Monoid {ℓ}
Ring→Monoid (A , ringstr _ _ _ _ _ R) = monoid _ _ _ (IsRing.·IsMonoid R)
|
oeis/255/A255381.asm | neoneye/loda-programs | 11 | 5773 | ; A255381: Number of strings of k+n decimal digits that contain one string of exactly k consecutive "0" digits, where k >= n.
; Submitted by <NAME>(s1)
; 1,18,261,3420,42300,504000,5850000,66600000,747000000,8280000000,90900000000,990000000000,10710000000000,115200000000000,1233000000000000,13140000000000000,139500000000000000,1476000000000000000,15570000000000000000,163800000000000000000,1719000000000000000000,18000000000000000000000,188100000000000000000000,1962000000000000000000000,20430000000000000000000000,212400000000000000000000000,2205000000000000000000000000,22860000000000000000000000000,236700000000000000000000000000
mov $3,2
mov $5,$0
lpb $3
sub $3,1
add $0,$3
sub $0,1
mov $2,$3
mov $4,$0
max $4,0
seq $4,81045 ; 10th binomial transform of (1,9,0,0,0,0,0,.....).
mul $2,$4
add $1,$2
mov $6,$4
lpe
min $5,1
mul $5,$6
sub $1,$5
mov $0,$1
|
other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/kart/risc.lzh/risc/join/Shadow.asm | prismotizm/gigaleak | 0 | 20963 | <reponame>prismotizm/gigaleak
Name: Shadow.asm
Type: file
Size: 12256
Last-Modified: '1992-11-18T01:48:26Z'
SHA-1: 68CC10A0F2BF0AB35D391C8806948F14C7F6C0FB
Description: null
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/init_scalar1.adb | best08618/asylo | 7 | 655 | -- { dg-do run }
-- { dg-options "-gnatws -gnatVa" }
pragma Initialize_Scalars;
procedure init_scalar1 is
type Fixed_3T is delta 2.0 ** (- 4)
range - 2.0 ** 19 .. (2.0 ** 19 - 2.0 ** (- 4));
for Fixed_3T'Size use 3*8;
Write_Value : constant Fixed_3T := Fixed_3T(524287.875);
type singleton is array (1 .. 1) of Fixed_3T;
pragma Pack (singleton);
it : Singleton;
begin
null;
end;
|
Mid-Term/Solution/Lab_Mid/ASM/MidQ3.asm | MohammadSakiL/CSE331L-Section-1-Fall20-NSU | 0 | 28799 | <gh_stars>0
.MODEL SMALL
.STACK 100H
.DATA
PROMPT_1 DB "ENTER A NUMBER1 : $"
PROMPT_2 DB "ENTER A NUMBER2 : $"
PROMPT_3 DB "SMALLEST ONE : $"
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
LEA DX, PROMPT_1
MOV AH, 9
INT 21H
MOV AH,1
INT 21H
MOV BL, AL
MOV AH, 2
MOV DL, 0DH
INT 21H
MOV DL,0AH
INT 21H
MOV DL,0AH
INT 21H
LEA DX, PROMPT_2
MOV AH, 9
INT 21H
MOV AH, 1
INT 21H
MOV BH, AL
MOV AH,2
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
LEA DX, PROMPT_3
MOV AH, 9
INT 21H
CMP BL,BH
JNBE @ELSE
MOV DL, BL
JMP @DISPLAY
@ELSE:
MOV DL, BH
@DISPLAY:
MOV AH, 2
INT 21H
MOV AH, 4CH
INT 21H
MAIN ENDP
END MAIN
|
oeis/062/A062731.asm | neoneye/loda-programs | 11 | 243941 | <reponame>neoneye/loda-programs
; A062731: Sum of divisors of 2*n.
; Submitted by <NAME>
; 3,7,12,15,18,28,24,31,39,42,36,60,42,56,72,63,54,91,60,90,96,84,72,124,93,98,120,120,90,168,96,127,144,126,144,195,114,140,168,186,126,224,132,180,234,168,144,252,171,217,216,210,162,280,216,248,240,210,180,360,186,224,312,255,252,336,204,270,288,336,216,403,222,266,372,300,288,392,240,378,363,294,252,480,324,308,360,372,270,546,336,360,384,336,360,508,294,399,468,465
add $0,1
mov $1,$0
mul $0,2
mov $2,$0
lpb $1
mov $3,$2
dif $3,$1
cmp $3,$2
cmp $3,0
mul $3,$1
add $0,$3
sub $1,1
lpe
add $0,1
|
ADL/drivers/stm32g474/stm32-cordic.adb | JCGobbi/Nucleo-STM32G474RE | 0 | 12227 |
package body STM32.CORDIC is
-------------------------
-- Set_CORDIC_Function --
-------------------------
procedure Set_CORDIC_Function
(This : in out CORDIC_Coprocessor;
Value : CORDIC_Function)
is
begin
This.CSR.FUNC := Value'Enum_Rep;
end Set_CORDIC_Function;
-------------------------
-- Get_CORDIC_Function --
-------------------------
function Get_CORDIC_Function (This : CORDIC_Coprocessor)
return CORDIC_Function
is
begin
return CORDIC_Function'Val (This.CSR.FUNC);
end Get_CORDIC_Function;
--------------------------
-- Set_CORDIC_Precision --
--------------------------
procedure Set_CORDIC_Precision
(This : in out CORDIC_Coprocessor;
Value : CORDIC_Iterations)
is
begin
This.CSR.PRECISION := Value'Enum_Rep;
end Set_CORDIC_Precision;
-------------------------------
-- Set_CORDIC_Scaling_Factor --
-------------------------------
procedure Set_CORDIC_Scaling_Factor
(This : in out CORDIC_Coprocessor;
Value : UInt3)
is
begin
This.CSR.SCALE := Value;
end Set_CORDIC_Scaling_Factor;
--------------------------
-- Set_CORDIC_Data_Size --
--------------------------
procedure Set_CORDIC_Data_Size
(This : in out CORDIC_Coprocessor;
Value : CORDIC_Data_Size)
is
begin
This.CSR.ARGSIZE := Value = Data_16_Bit;
This.CSR.RESSIZE := Value = Data_16_Bit;
end Set_CORDIC_Data_Size;
--------------------------
-- Get_CORDIC_Data_Size --
--------------------------
function Get_CORDIC_Data_Size
(This : CORDIC_Coprocessor)
return CORDIC_Data_Size
is
begin
return (if This.CSR.ARGSIZE then Data_16_Bit else Data_32_Bit);
end Get_CORDIC_Data_Size;
---------------------------------
-- Set_CORDIC_Arguments_Number --
---------------------------------
procedure Set_CORDIC_Arguments_Number
(This : in out CORDIC_Coprocessor;
Value : CORDIC_Arguments_Number)
is
begin
This.CSR.NARGS := Value = Two_32_Bit;
end Set_CORDIC_Arguments_Number;
---------------------------------
-- Get_CORDIC_Arguments_Number --
---------------------------------
function Get_CORDIC_Arguments_Number
(This : CORDIC_Coprocessor)
return CORDIC_Arguments_Number
is
begin
return (if This.CSR.NARGS then Two_32_Bit else One_32_Bit);
end Get_CORDIC_Arguments_Number;
-------------------------------
-- Set_CORDIC_Results_Number --
-------------------------------
procedure Set_CORDIC_Results_Number
(This : in out CORDIC_Coprocessor;
Value : CORDIC_Arguments_Number)
is
begin
This.CSR.NRES := Value = Two_32_Bit;
end Set_CORDIC_Results_Number;
-------------------------------
-- Get_CORDIC_Results_Number --
-------------------------------
function Get_CORDIC_Results_Number
(This : CORDIC_Coprocessor)
return CORDIC_Arguments_Number
is
begin
return (if This.CSR.NRES then Two_32_Bit else One_32_Bit);
end Get_CORDIC_Results_Number;
-----------------------------------
-- Configure_CORDIC_Coprocesssor --
-----------------------------------
procedure Configure_CORDIC_Coprocessor
(This : in out CORDIC_Coprocessor;
Operation : CORDIC_Function;
Precision : CORDIC_Iterations := Iteration_20;
Scaling : UInt3 := 0;
Data_Size : CORDIC_Data_Size)
is
begin
This.CSR.FUNC := Operation'Enum_Rep;
This.CSR.PRECISION := Precision'Enum_Rep;
This.CSR.SCALE := Scaling;
This.CSR.ARGSIZE := Data_Size = Data_16_Bit;
This.CSR.RESSIZE := Data_Size = Data_16_Bit;
case Operation is
when Cosine | Sine | Phase | Modulus =>
case Data_Size is
when Data_32_Bit =>
This.CSR.NARGS := True; -- Two_32_Bit Arguments
This.CSR.NRES := True; -- Two_32_Bit Results
when Data_16_Bit =>
This.CSR.NARGS := False; -- One_32_Bit Argument
This.CSR.NRES := False; -- One_32_Bit Result
end case;
when Hyperbolic_Cosine | Hyperbolic_Sine =>
case Data_Size is
when Data_32_Bit =>
This.CSR.NARGS := False; -- One_32_Bit Argument
This.CSR.NRES := True; -- Two_32_Bit Results
when Data_16_Bit =>
This.CSR.NARGS := False; -- One_32_Bit Argument
This.CSR.NRES := False; -- One_32_Bit Result
end case;
when Arctangent | Hyperbolic_Arctangent | Natural_Logarithm | Square_Root =>
case Data_Size is
when Data_32_Bit =>
This.CSR.NARGS := False; -- One_32_Bit Argument
This.CSR.NRES := False; -- One_32_Bit Result
when Data_16_Bit =>
This.CSR.NARGS := False; -- One_32_Bit Argument
This.CSR.NRES := False; -- One_32_Bit Result
end case;
end case;
end Configure_CORDIC_Coprocessor;
---------------------
-- Get_CORDIC_Data --
---------------------
function Get_CORDIC_Data (This : CORDIC_Coprocessor) return UInt32 is
begin
return This.RDATA;
end Get_CORDIC_Data;
------------
-- Status --
------------
function Status
(This : CORDIC_Coprocessor;
Flag : CORDIC_Status) return Boolean
is
begin
case Flag is
when Result_Ready =>
return This.CSR.RRDY;
end case;
end Status;
-------------------
-- Set_Interrupt --
-------------------
procedure Set_Interrupt
(This : in out CORDIC_Coprocessor;
Enable : Boolean)
is
begin
This.CSR.IEN := Enable;
end Set_Interrupt;
-----------------------
-- Interrupt_Enabled --
-----------------------
function Interrupt_Enabled
(This : CORDIC_Coprocessor) return Boolean
is
begin
return This.CSR.IEN;
end Interrupt_Enabled;
-------------
-- Set_DMA --
-------------
procedure Set_DMA
(This : in out CORDIC_Coprocessor;
DMA : CORDIC_DMA;
Enable : Boolean)
is
begin
case DMA is
when Read_DMA =>
This.CSR.DMAREN := Enable;
when Write_DMA =>
This.CSR.DMAWEN := Enable;
end case;
end Set_DMA;
-----------------
-- DMA_Enabled --
-----------------
function DMA_Enabled
(This : CORDIC_Coprocessor;
DMA : CORDIC_DMA)
return Boolean
is
begin
case DMA is
when Read_DMA =>
return This.CSR.DMAREN;
when Write_DMA =>
return This.CSR.DMAWEN;
end case;
end DMA_Enabled;
end STM32.CORDIC;
|
externals/mpir-3.0.0/mpn/x86_64w/skylake/popcount.asm | JaminChan/eos_win | 12 | 15145 | <filename>externals/mpir-3.0.0/mpn/x86_64w/skylake/popcount.asm<gh_stars>10-100
; PROLOGUE(mpn_popcount)
; AMD64 mpn_popcount
; Copyright 2009 <NAME>
; This file is part of the MPIR Library.
; The MPIR Library is free software; you can redistribute it and/or modify
; it under the terms of the GNU Lesser General Public License as published
; by the Free Software Foundation; either verdxon 2.1 of the License, or (at
; your option) any later verdxon.
; The MPIR 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 Lesser General Public
; License for more details.
; You should have received a copy of the GNU Lesser General Public License
; along with the MPIR Library; see the file COPYING.LIB. If not, write
; to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
; Boston, MA 02110-1301, USA.
; mpn_limb_t mpn_popcount(mp_ptr,mp_size_t)
; rax rdi, rsi
; eax rcx, rdx
%include 'yasm_mac.inc'
CPU nehalem
BITS 64
LEAF_PROC mpn_popcount
mov r8, 5
lea rcx, [rcx+rdx*8-40]
xor eax, eax
sub r8, rdx
jnc .1
xalign 16
.0:
popcnt r9, [rcx+r8*8]
popcnt r10, [rcx+r8*8+8]
popcnt r11, [rcx+r8*8+16]
popcnt rdx, [rcx+r8*8+24]
add rax, r9
add rax, rdx
add rax, r10
popcnt r9, [rcx+r8*8+32]
popcnt r10, [rcx+r8*8+40]
add rax, r9
add rax, r11
add rax, r10
add r8, 6
jnc .0
.1:
lea rdx, [rel .2]
lea r8, [r8+r8*8]
add rdx, r8
jmp rdx
.2:
nop
popcnt r9, [rcx]
add rax, r9
.3:
popcnt r10, [rcx+8]
add rax, r10
.4: popcnt r11, [rcx+16]
add rax, r11
.5: popcnt rdx, [rcx+24]
add rax, rdx
.6: popcnt r9, [rcx+32]
add rax, r9
.7: ret
end
|
programs/oeis/139/A139185.asm | neoneye/loda | 22 | 6978 | ; A139185: a(n) = (n! - 10)/10.
; 11,71,503,4031,36287,362879,3991679,47900159,622702079,8717829119,130767436799,2092278988799,35568742809599,640237370572799,12164510040883199,243290200817663999,5109094217170943999,112400072777760767999,2585201673888497663999,62044840173323943935999,1551121004333098598399999,40329146112660563558399999,1088886945041835216076799999,30488834461171386050150399999,884176199373970195454361599999,26525285981219105863630847999999,822283865417792281772556287999999,26313083693369353016721801215999999,868331761881188649551819440127999999
add $0,5
mov $1,1
lpb $0
mul $1,$0
sub $0,1
lpe
mul $1,8
sub $1,960
div $1,80
add $1,11
mov $0,$1
|
mat/src/memory/mat-memory.ads | stcarrez/mat | 7 | 28818 | <filename>mat/src/memory/mat-memory.ads
-----------------------------------------------------------------------
-- Memory - Memory slot
-- Copyright (C) 2014, 2015, 2019 <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 Ada.Containers.Ordered_Maps;
with Ada.Strings.Unbounded;
with ELF;
with MAT.Types;
with MAT.Frames;
with MAT.Events;
package MAT.Memory is
type Allocation is record
Size : MAT.Types.Target_Size;
Frame : Frames.Frame_Type;
Time : MAT.Types.Target_Tick_Ref;
Thread : MAT.Types.Target_Thread_Ref;
Event : MAT.Events.Event_Id_Type;
end record;
-- Statistics about memory allocation.
type Memory_Info is record
Total_Size : MAT.Types.Target_Size := 0;
Alloc_Count : Natural := 0;
Min_Slot_Size : MAT.Types.Target_Size := 0;
Max_Slot_Size : MAT.Types.Target_Size := 0;
Min_Addr : MAT.Types.Target_Addr := 0;
Max_Addr : MAT.Types.Target_Addr := 0;
end record;
-- Description of a memory region.
type Region_Info is record
Start_Addr : MAT.Types.Target_Addr := 0;
End_Addr : MAT.Types.Target_Addr := 0;
Size : MAT.Types.Target_Size := 0;
Flags : ELF.Elf32_Word := 0;
Path : Ada.Strings.Unbounded.Unbounded_String;
end record;
use type MAT.Types.Target_Addr;
package Allocation_Maps is
new Ada.Containers.Ordered_Maps (Key_Type => MAT.Types.Target_Addr,
Element_Type => Allocation);
subtype Allocation_Map is Allocation_Maps.Map;
subtype Allocation_Cursor is Allocation_Maps.Cursor;
-- Define a map of <tt>Memory_Info</tt> keyed by the thread Id.
-- Such map allows to give the list of threads and a summary of their allocation.
use type MAT.Types.Target_Thread_Ref;
package Memory_Info_Maps is
new Ada.Containers.Ordered_Maps (Key_Type => MAT.Types.Target_Thread_Ref,
Element_Type => Memory_Info);
subtype Memory_Info_Map is Memory_Info_Maps.Map;
subtype Memory_Info_Cursor is Memory_Info_Maps.Cursor;
type Frame_Info is record
Thread : MAT.Types.Target_Thread_Ref;
Memory : Memory_Info;
end record;
-- Define a map of <tt>Frame_Info</tt> keyed by the backtrace function address
-- that performed the memory allocation directly or indirectly.
package Frame_Info_Maps is
new Ada.Containers.Ordered_Maps (Key_Type => MAT.Types.Target_Addr,
Element_Type => Frame_Info);
subtype Frame_Info_Map is Frame_Info_Maps.Map;
subtype Frame_Info_Cursor is Frame_Info_Maps.Cursor;
package Region_Info_Maps is
new Ada.Containers.Ordered_Maps (Key_Type => MAT.Types.Target_Addr,
Element_Type => Region_Info);
subtype Region_Info_Map is Region_Info_Maps.Map;
subtype Region_Info_Cursor is Region_Info_Maps.Cursor;
end MAT.Memory;
|
basic/src/commands/list.asm | paulscottrobson/eris | 13 | 172283 | ; *****************************************************************************
; *****************************************************************************
;
; Name: list.asm
; Purpose: List program.
; Created: 11th March 2020
; Reviewed: 17th March 2020
; Author: <NAME> (<EMAIL>)
;
; *****************************************************************************
; *****************************************************************************
.Command_List ;; [list]
mov r0,#12 ; clear the screen-my decision !
jsr #OSPrintCharacter
;
; Find the start
;
clr r6 ; R6 is the lowest listed line number
clr r7 ; R7 is the current indentation.
;
ldm r0,r11,#0 ; read next token.
sknz r0 ; if EOL start from 0
jmp #_CLHaveLine
xor r0,#TOK_COLON ; if : start from 0
sknz r0
jmp #_CLHaveLine
;
ldm r0,r11,#0 ; get next token again
and r0,#$C000 ; is it an identifier
xor r0,#$4000
skz r0
jmp #_CLDoAsInteger
;
mov r1,r11,#0 ; we have to convert the identifier so it is a array
._CLMakeArray ; because that's how it's stored.
ldm r0,r1,#0 ; set array bit
add r0,#$0800
stm r0,r1,#0
inc r1 ; bump
ror r0,#14 ; until end bit set
skm r0
jmp #_CLMakeArray
jsr #ProcedureSearch ; find procedure
ldm r6,r2,#1 ; line number in R6
jmp #_CLHaveLine
._CLDoAsInteger
jsr #EvaluateInteger ; get start line into R6
mov r6,r0,#0
._CLHaveLine
;
; Now scan for lines >= R6
;
ldm r11,#programCode ; R11 is the pointer to the current line.
._CLListLoop
jsr #OSGetTextPos ; get text position
sub r1,#CharHeight-4 ; check off the bottom
sklt
jmp #WarmStartNoReady
;
ldm r0,r11,#0 ; get the offset, if zero, warm start.
sknz r0
jmp #WarmStartNoReady
;
ldm r0,r11,#1 ; get line number
skp r0 ; we do not list -ve numbers by default
jmp #_CLListNextLine
sknz r0 ; or line zero
jmp #_CLListNextLine
;
sub r0,r6,#0 ; compare against the lowest line
sklt ; out of range
jsr #ListOneLine
._CLListNextLine
ldm r0,r11,#0 ; get offset
add r11,r0,#0 ; add to current line
jmp #_CLListLoop ; and loop around
; *****************************************************************************
;
; List line at R11
;
; *****************************************************************************
.ListOneLine
push r6,r10,r11,link
;
mov r10,r11,#0 ; save SOL in R10
mov r0,#-indentStep ; do down indents before
mov r1,#13<<9
jsr #ListCheckAdjustIndent
;
; Print line number
;
mov r0,#theme_line+$10 ; line number theme
jsr #OSPrintCharacter
ldm r0,r11,#1 ; get line number
mov r1,#10 ; base to use
jsr #OSIntToStr ; convert to string.
jsr #OSPrintString ; print string.
ldm r0,r0,#0 ; get string length
mov r1,#6 ; get indent + 6
skm r7 ; add indent if not -ve
add r1,r7,#0
sub r1,r0,#0 ; subtract length of string, spacing to code
._LOLSpacing
mov r0,#$20 ; pad out so start of lines align with indents
jsr #OSPrintCharacter
dec r1
skz r1
jmp #_LOLSpacing
;
add r11,#2 ; point to first token.
clr r8 ; clear last-is-identifier flag
stm r14,#lastListToken ; clear the last token value.
;
; List tokens until done.
;
._LOLLoop
ldm r0,r11,#0 ; check end of line
sknz r0
jmp #_LOLExit
jsr #DecodeToken ; decode one token
jmp #_LOLLoop
._LOLExit
jsr #OSPrintInline ; black background and new line
string "[10][0F][12][0D]"
mov r0,#indentStep ; do up indents after
mov r1,#15<<9
jsr #ListCheckAdjustIndent
skp r7 ; clear indent if -ve
clr r7 ; most likely started editing in a structure
pop r6,r10,r11,link
ret
; *****************************************************************************
;
; Decode one token at [R11]
;
; *****************************************************************************
.DecodeToken
push link
clr r9 ; clear the position index in this token value.
ldm r0,r11,#0 ; get this token and save on stack
push r0
;
; Check for constant first. This is either $8000-$FFFF or
; the Constant Shift followed by that value.
;
mov r1,#$8000 ; this is used to flip the constant
ldm r0,r11,#0 ; is it -ve, it's a constant
skp r0
jmp #_DTDigit
xor r0,#TOK_VBARCONSTSHIFT ; is it the constant shift ?
skz r0
jmp #_DTNotConstant
clr r1 ; we don't flip the constant
inc r11 ; skip over constant shift
._DTDigit
mov r0,#theme_const+$10
jsr #OSPrintCharacter
ldm r0,r11,#0 ; get the value and skip it
inc r11
xor r0,r1,#0 ; flip it
mov r1,#10 ; start with base 10
ldm r2,#lastListToken ; what was the previous list token ?
xor r2,#TOK_PERCENT ; if % base 2
sknz r2
mov r1,#2
xor r2,#TOK_PERCENT^TOK_AMPERSAND ; if & base 16
sknz r2
mov r1,#16
jsr #OSIntToStr ; convert to string and print it
jsr #ListPrintString
jmp #_DTExit
;
; Check for quoted string
;
._DTNotConstant
ldm r0,r11,#0 ; check if 01xx
and r0,#$FF00
xor r0,#$0100
skz r0
jmp #_DTNotString
mov r0,#theme_string+$10 ; string printing code
jsr #OSPrintCharacter
mov r0,#'"'
jsr #ListPrintCharacter
mov r0,r11,#1 ; print the string
jsr #ListPrintString
mov r0,#'"'
jsr #ListPrintCharacter
;
ldm r0,r11,#0 ; get the token, with the size.
and r0,#$00FF
add r11,r0,#0 ; skip over the string
jmp #_DTExit
;
; So it's now either a token, or an identifier.
;
._DTNotString
ldm r0,r11,#0 ; get the token
add r0,r0,#0 ; shift bit 14 into bit 15
skm r0 ; identifier if set 01xx xxxx xxxx xxxx
jmp #_DTIsToken ; token if 001x xxxx xxxx xxxx
;
; It's an identifier
;
mov r0,#theme_ident+$10
jsr #OSPrintCharacter
mov r0,r11,#0 ; so print identifier here
jsr #ListPrintEncodedIdentifier
mov r11,r0,#0 ; and update when finished.
jmp #_DTExit
;
; It's a token
;
._DTIsToken
mov r0,#theme_keyword+$10 ; print quote in reverse blue
jsr #OSPrintCharacter
ldm r0,r11,#0
xor r0,#TOK_QUOTE
skz r0
jmp #_DTNoReverse
ldm r0,#colourMask ; can we support reverse ?
sub r0,#4 ; need at least 3 planes.
skge
jmp #_DTNoReverse
jsr #OSPrintInline
string "[14][0F]"
._DTNoReverse
ldm r1,r11,#0 ; get the token
and r1,#$01FF ; this is the token ID, lower 9 bits
mov r2,#TokeniserWords ; this is the table address
._DTFindToken
sknz r1 ; go forward till found the token text record
jmp #_DTHaveToken
dec r1 ; dec count
ldm r0,r2,#0 ; get string length
and r0,#$00FF
add r2,r0,#1 ; advance to next record
jmp #_DTFindToken
;
._DTHaveToken
mov r0,r2,#1 ; R0 now contains the token text address
ldm r3,r0,#0 ; get the first token
skm r3 ; +ve print as identifier
jsr #ListPrintEncodedIdentifier
skp r3
jsr #ListPrintPunctuation
inc r11 ; advance over token
._DTExit
pop r0 ; get the token and update last token
stm r0,#lastListToken
pop link
ret
; *****************************************************************************
;
; Check code line at R10 for command type R1, when found, adjust
; indent in R7 by R0
;
; down indenting is done before list
; up indent is done after list
; else .... is out by one.
;
; *****************************************************************************
.ListCheckAdjustIndent
push r0,r1,r2,r3,r4,r10
inc r10
clr r3 ; count all indents
mov r4,r7,#0 ; save original indent
._LCAILoop
inc r10 ; pre inc
._LCAILoopNoInc
ldm r2,r10,#0 ; check for strings/EOL
sknz r2
jmp #_LCAIExit
and r2,#$FF00
xor r2,#$0100
sknz r2
jmp #_LCAIStringSkip
;
ldm r2,r10,#0 ; get token back.
and r2,#$E000 ; is it a token
xor r2,#$2000
skz r2
jmp #_LCAILoop ; if not go back.
;
ldm r2,r10,#0 ; get token back
and r2,#15<<9 ; isolate type
add r3,r2,#0 ; add to total indents
sub r3,#14<<9 ; adjust it back.
xor r2,r1,#0 ; found it ?
sknz r2
add r7,r0,#0 ; add indent adjustment
jmp #_LCAILoop
;
._LCAIStringSkip:
ldm r2,r10,#0 ; add string data length
and r2,#$00FF
add r10,r2,#0
jmp #_LCAILoopNoInc
._LCAIExit
sknz r3 ; if the balance is zero do not adjust indentation
mov r7,r4,#0
pop r0,r1,r2,r3,r4,r10
ret
|
contrib/boringssl-cmake/win-x86_64/crypto/fipsmodule/rdrand-x86_64.asm | pdv-ru/ClickHouse | 15,577 | 6789 | <reponame>pdv-ru/ClickHouse
; This file is generated from a similarly-named Perl script in the BoringSSL
; source tree. Do not edit by hand.
default rel
%define XMMWORD
%define YMMWORD
%define ZMMWORD
%ifdef BORINGSSL_PREFIX
%include "boringssl_prefix_symbols_nasm.inc"
%endif
section .text code align=64
global CRYPTO_rdrand
ALIGN 16
CRYPTO_rdrand:
xor rax,rax
DB 73,15,199,240
adc rax,rax
mov QWORD[rcx],r8
DB 0F3h,0C3h ;repret
global CRYPTO_rdrand_multiple8_buf
ALIGN 16
CRYPTO_rdrand_multiple8_buf:
test rdx,rdx
jz NEAR $L$out
mov r8,8
$L$loop:
DB 73,15,199,241
jnc NEAR $L$err
mov QWORD[rcx],r9
add rcx,r8
sub rdx,r8
jnz NEAR $L$loop
$L$out:
mov rax,1
DB 0F3h,0C3h ;repret
$L$err:
xor rax,rax
DB 0F3h,0C3h ;repret
|
src/tk/tk-ttklabelframe.ads | thindil/tashy2 | 2 | 18981 | <gh_stars>1-10
-- Copyright (c) 2021 <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 Tcl.Strings; use Tcl.Strings;
with Tk.Widget; use Tk.Widget;
with Tk.TtkWidget; use Tk.TtkWidget;
-- ****h* Tk/TtkLabelFrame
-- FUNCTION
-- Provides code for manipulate Tk widget ttk::labelframe
-- SOURCE
package Tk.TtkLabelFrame is
-- ****
--## rule off REDUCEABLE_SCOPE
-- ****t* TtkLabelFrame/TtkLabelFrame.Tk_Frame
-- FUNCTION
-- The Tk identifier of the ttk::labelframe
-- HISTORY
-- 8.6.0 - Added
-- SOURCE
subtype Ttk_Label_Frame is Ttk_Widget;
-- ****
-- ****s* TtkLabelFrame/TtkLabelFrame.Ttk_Label_Frame_Options
-- FUNCTION
-- Data structure for all available options for the Tk ttk::labelframe which can
-- be changed after creation of a widget
-- OPTIONS
-- Border_Width - The width of the ttk::labelframe's border
-- Height - Height of the ttk::labelframe.
-- Label_Anchor - The direction where to place the lable of Tk
-- ttk::labelframe. Works only when Text option isn't empty
-- Label_Widget - Tk_Widget used as a label for Tk ttk::labelframe.
-- Padding - Amount of extra space to allocate for the ttk::labelframe. If some
-- elemets are empty then, bottom defaults to top, right defaults
-- to left, and top defaults to left. Order of the elements:
-- left, top, right, bottom
-- Relief - 3-D effect desired for the ttk::labelframe
-- Text - The text which will be displayed in label of Tk
-- ttk::labelframe
-- Width - Width of the ttk::labelframe
-- Underline - The index of the character in the ttk::labelframe text
-- which will be underlined. The index starts from 0
-- HISTORY
-- 8.6.0 - Added
-- SOURCE
type Ttk_Label_Frame_Options is new Ttk_Widget_Options with record
Border_Width: Pixel_Data := Empty_Pixel_Data;
Height: Pixel_Data := Empty_Pixel_Data;
Label_Anchor: Anchor_Directions := NONE;
Label_Widget: Tk_Widget := Null_Widget;
Padding: Padding_Data := Empty_Padding_Data;
Relief: Relief_Type := NONE;
Text: Tcl_String := Null_Tcl_String;
Underline: Extended_Natural := -1;
Width: Pixel_Data := Empty_Pixel_Data;
end record;
-- ****
-- ****f* TtkLabelFrame/TtkLabelFrame.Configure
-- FUNCTION
-- Set the selected options for the selected ttk::labelframe
-- PARAMETERS
-- Frame_Widget - Ttk_Label_Frame which options will be set
-- Options - The record with new values for the ttk::labelframe options
-- HISTORY
-- 8.6.0 - Added
-- EXAMPLE
-- -- Set background to black for ttk::labelframe My_Frame
-- Configure(My_Frame, (Background => To_Tcl_String("black"), others => <>));
-- SEE ALSO
-- Frame.Get_Options
-- COMMANDS
-- Widget configure Options
-- SOURCE
procedure Configure
(Frame_Widget: Ttk_Label_Frame; Options: Ttk_Label_Frame_Options) with
Pre'Class => Frame_Widget /= Null_Widget,
Test_Case => (Name => "Test_Configure_TtkLabelFrame", Mode => Nominal);
-- ****
-- ****f* TtkLabelFrame/TtkLabelFrame.Create_(function)
-- FUNCTION
-- Create a new Tk ttk::labelframe widget with the selected pathname and options
-- PARAMETERS
-- Path_Name - Tk pathname for the newly created ttk::labelframe
-- Options - Options for the newly created ttk::labelframe
-- Interpreter - Tcl interpreter on which the ttk::labelframe will be created. Can
-- be empty. Default value is the default Tcl interpreter
-- RESULT
-- The Tk identifier of the newly created ttk::labelframe widget
-- HISTORY
-- 8.6.0 - Added
-- EXAMPLE
-- -- Create the ttk::labelframe with pathname .myframe and black background
-- My_Frame: constant Ttk_Label_Frame := Create(".myframe", (Background => To_Tcl_String("black"),
-- others => <>));
-- SEE ALSO
-- TtkLabelFrame.Create_(procedure)
-- COMMANDS
-- ttk::labelframe Path_Name Options
-- SOURCE
function Create
(Path_Name: Tk_Path_String; Options: Ttk_Label_Frame_Options;
Interpreter: Tcl_Interpreter := Get_Interpreter)
return Ttk_Label_Frame with
Pre'Class => Path_Name'Length > 0 and Interpreter /= Null_Interpreter,
Test_Case => (Name => "Test_Create_TtkLabelFrame1", Mode => Nominal);
-- ****
-- ****f* TtkLabelFrame/TtkLabelFrame.Create_(procedure)
-- FUNCTION
-- Create a new Tk ttk::frame widget with the selected pathname and options
-- PARAMETERS
-- Frame_Widget - Ttk_Label_Frame identifier which will be returned
-- Path_Name - Tk pathname for the newly created ttk::labelframe
-- Options - Options for the newly created ttk::labelframe
-- Interpreter - Tcl interpreter on which the ttk::labelframe will be created. Can
-- be empty. Default value is the default Tcl interpreter
-- OUTPUT
-- The Widget parameter as Tk identifier of the newly created ttk::labelframe widget
-- HISTORY
-- 8.6.0 - Added
-- EXAMPLE
-- -- Create the ttk::labelframe with pathname .myframe
-- declare
-- My_Frame: Ttk_Label_Frame;
-- begin
-- Create(My_Frame, ".myframe", Default_Ttk_Label_Frame_Create_Options);
-- end;
-- SEE ALSO
-- Ttk_Label_Frame.Create_(function)
-- COMMANDS
-- ttk::labelframe Path_Name Options
-- SOURCE
procedure Create
(Frame_Widget: out Ttk_Label_Frame; Path_Name: Tk_Path_String;
Options: Ttk_Label_Frame_Options;
Interpreter: Tcl_Interpreter := Get_Interpreter) with
Pre'Class => Path_Name'Length > 0 and Interpreter /= Null_Interpreter,
Test_Case => (Name => "Test_Create_TtkLabelFrame2", Mode => Nominal);
-- ****
-- ****f* TtkLabelFrame/TtkLabelFrame.Get_Options
-- FUNCTION
-- Get all values of Tk options of the selected ttk::labelframe
-- PARAMETERS
-- Frame_Widget - Ttk_Label_Frame which options' values will be taken
-- RESULT
-- Ttk_Label_Frame_Options record with values of the selected ttk::labelframe
-- options
-- HISTORY
-- 8.6.0 - Added
-- EXAMPLE
-- -- Get all values of option of ttk::labelframe with pathname .myframe
-- My_Frame_Options: constant Ttk_Label_Frame_Options := Get_Options(Get_Widget(".myframe"));
-- COMMANDS
-- Widget configure
-- SOURCE
function Get_Options
(Frame_Widget: Ttk_Label_Frame) return Ttk_Label_Frame_Options with
Pre'Class => Frame_Widget /= Null_Widget,
Test_Case => (Name => "Test_Get_Options_TtkLabelFrame", Mode => Nominal);
-- ****
-- ****d* TtkLabelFrame/TtkLabelFrame.Default_Ttk_Label_Frame_Options
-- FUNCTION
-- Default options for ttk::labelframe widget
-- HISTORY
-- 8.6.0 - Added
-- SOURCE
Default_Ttk_Label_Frame_Options: constant Ttk_Label_Frame_Options :=
Ttk_Label_Frame_Options'(others => <>);
-- ****
--## rule on REDUCEABLE_SCOPE
end Tk.TtkLabelFrame;
|
programs/oeis/191/A191402.asm | jmorken/loda | 1 | 29270 | <reponame>jmorken/loda
; A191402: A000201(n)+A000201(n+1).
; 1,4,7,10,14,17,20,23,26,30,33,36,40,43,46,49,52,56,59,62,65,68,72,75,78,82,85,88,91,94,98,101,104,108,111,114,117,120,124,127,130,133,136,140,143,146,150,153,156,159,162,166,169,172,175,178,182,185,188,192,195,198,201,204,208,211,214,218,221,224
mul $0,2
cal $0,187580 ; Rank transform of the sequence 2*floor(n/2); complement of A187581.
mov $1,$0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.