I have tried NASM, but I dont like it, it works better on linux and my main development platform is windows.
I have also tried FASM, its better but I couldnt find good documentation on it.
I dont care for the syntex although I like the Intel syntex more e.g.

mov eax, 4

I want an assembler that is easy to learn, and have good documentation from which I can learn and that I can program bootloaders and other chipset based stuff like writing drivers for security cameras etc.

I am currently developing from an 64 bit cpu, so the assembler should support atleast 32 bit / 64 bit.
My main platform is 64-bit windows 7.

Thanks...

Howdy Folks!
Another line!

However; I simlpy get:

Another line!

Here is my code:

SECTION .text
            global start
START:
            mov eax, 4          ;sys_write
            mov ebx, 1          ;output to screen
            mov ecx, string ;creates address for my string variable
            mov ecx, string2    ;creates address for another string
            mov edx, length ;creates address for my length variable
            mov edx, length2    ;creates address for another length
            int 80h             ;call the kernel
            mov eax, 1          ;sys_exit
            mov ebx, 0          ;no error exit
            int 80h             ;call the kernel
SECTION .data
string: db 'Howdy Folks!', 0Ah  ;output string
length: equ 12                      ;length of string
string2: db 'Another line!', 0Ah    ;output another string
length2: equ 13                 ;length of string2

Where did I go wrong?
Did I accidentally overwrite string ('Howdy Folks') with the value of string2 ('Another Line!')?
How can I go about fixing this?
Also, are my comments appropriate with how the line actually functions?

For instance;

int 80h             ;call the kernel

Does this line really call the kernel?
If so what is it actually doing there?

Thanks for any help.

A) Did the assembler simply copy-paste the library code in (like a header file in c/c++)
B) Where can I learn general assembly?
C) I noticed that pretty much every tutorial uses different layout (IE: data:code: vs section data, etc) what are these and how can I know which one is correct?
D) I always hear that you need to specialize your assembly code to your exact operating system, but then how come I can run certain programs across all the systems? What sort of sorcery is going on?!

Line 7 column five: "li": too many or incorrectly formatted operands. Expected li $t1, -100
Line 94 column 23: "$t0" : operand is of incorrect type
Line 97 column 23: "0xfffffffc" : operand is of incorrect type
Line 289 column 23: "$t1": operand is of incorrect type

I need to get it working in mars.I'd be grateful for your help.

and below source code: ( I marked the error lines on the left )

my code:

.text
main:

# extend data segment

    li      $v0, 9              # sbrk syscall
7 - li      $a0, 500000+4       # the the maximum data size (a multiple of 4) plus an extra word
    syscall
    bnez    $v0, store

    li      $v0, 4              # print error string
    la      $a0, memory_error
    syscall
    b       exit

store:
    sw      $v0, buffer         # store the file buffer address

# get input file name from user

get_filename:
    li      $v0, 4              # print prompt for input file
    la      $a0, prompt
    syscall

    li      $v0, 8              # read input filename
    la      $a0, filename
    li      $a1, 100
    syscall

# search for \n and replace it with terminating 0

    li      $t1, -1             # filename length (will be determined in the following loop)

search:
    lb      $t0, 0($a0)
    add     $a0, $a0, 1
    add     $t1, $t1, 1
    bne     $t0, 0x0a, search

    sb      $zero, -1($a0)

    beqz    $t1, exit           # exit if no filename was given

# open and read the file

    li      $v0, 13             # open file syscall
    la      $a0, filename
    li      $a1, 0              # flags
    li      $a2, 0              # mode (ignored)
    syscall
    bgez    $v0, read_file

    li      $v0, 4              # print error string
    la      $a0, open_error
    syscall
    b       exit

read_file:
    sw      $v0, descriptor

    li      $v0, 14             # read from file syscall
    lw      $a0, descriptor     # the file descriptor
    lw      $a1, buffer
    li      $a2, 500000         # max number of bytes to read
    syscall
    bgez    $v0, process

    li      $v0, 4              # print error string
    la      $a0, read_error
    syscall
    b       exit


process:
    srl     $s0, $v0, 1         # number of halfwords
    and     $t0, $v0, 0x1
    beqz    $t0, number_of_words
    add     $s0, $s0, 1         # round up (i.e. add 1) if the data size is not a multiple of 2

number_of_words:
    srl     $s1, $v0, 2         # number of words
    and     $t0, $v0, 0x3       # the remainder from division by 4 (number of effective data bytes in the last word)
    beqz    $t0, pad
    add     $s1, $s1, 1         # round up

# pad the data with 0s

pad:
    li      $t1, 4
    sub     $t0, $t1, $t0       # 4 minus the above remainder (specifies how many bytes to zero in a bit mask)
    sll     $t0, $t0, 3         # multiply by 8 to determine the number of zero bits to insert from the right 
    li      $t1, 0xffffffff     # initial value of the mask
94- srl     $t1, $t1, $t0       # insert zero bits and form actual bit mask (note: little endian order)

    add     $t2, $a1, $v0           # the address of the end of the data
97- and     $t2, $t2, 0xfffffffc    # the address (divisible by 4) that will be affected by the bit mask

    lw      $t0, ($t2)          # load the word that will contain the padding 0 bytes, note: this step can access (but not change) a whole extra word after the data when its size is a multiple of 4
    and     $t0, $t0, $t1       # zero the unused bytes (using the bit mask)
    sw      $t0, ($t2)          # store it

# modular sum

    # 8-bit checksum

    move    $t0, $v0            # number of bytes of the data (a counter)
    move    $t1, $a1            # the start address of the data
    li      $s2, 0              # clear the "accumulator"

sum8:
    lbu     $t2, ($t1)
    add     $t1, $t1, 1
    addu    $s2, $s2, $t2
    sub     $t0, $t0, 1
    bnez    $t0, sum8

    sll     $s2, $s2, 24        # sign extend byte to word (first align the sign bit of the byte to make use of arithmetic shifting)
    sra     $s2, $s2, 24        # insert the sign bit between bits 31-8

    # 16-bit checksum

    move    $t0, $s0
    move    $t1, $a1
    li      $s3, 0

sum16:
    lhu     $t2, ($t1)
    add     $t1, $t1, 2
    addu    $s3, $s3, $t2
    sub     $t0, $t0, 1
    bnez    $t0, sum16

    sll     $s3, $s3, 16        # sign extend halfword to word
    sra     $s3, $s3, 16

    # 32-bit checksum

    move    $t0, $s1
    move    $t1, $a1
    li      $s4, 0

sum32:
    lw      $t2, ($t1)
    add     $t1, $t1, 4
    addu    $s4, $s4, $t2
    sub     $t0, $t0, 1
    bnez    $t0, sum32

# parity check

    # 8-bit XOR value

    move    $t0, $v0
    move    $t1, $a1
    li      $s5, 0

xor8:
    lbu     $t2, ($t1)
    add     $t1, $t1, 1
    xor     $s5, $s5, $t2
    sub     $t0, $t0, 1
    bnez    $t0, xor8

    # 16-bit XOR value

    move    $t0, $s0
    move    $t1, $a1
    li      $s6, 0

xor16:
    lhu     $t2, ($t1)
    add     $t1, $t1, 2
    xor     $s6, $s6, $t2
    sub     $t0, $t0, 1
    bnez    $t0, xor16

    # 32-bit XOR value

    move    $t0, $s1
    move    $t1, $a1
    li      $s7, 0

xor32:
    lw      $t2, ($t1)
    add     $t1, $t1, 4
    xor     $s7, $s7, $t2
    sub     $t0, $t0, 1
    bnez    $t0, xor32


# report results to the user

    # 8-bit checksum

    li      $v0, 4              # print string
    la      $a0, checksum8
    syscall

    li      $v0, 1              # print int
    move    $a0, $s2
    syscall

    li      $v0, 4              # print string
    la      $a0, new_line
    syscall

    # 16-bit checksum

    li      $v0, 4              # print string
    la      $a0, checksum16
    syscall

    li      $v0, 1              # print int
    move    $a0, $s3
    syscall

    li      $v0, 4              # print string
    la      $a0, new_line
    syscall

    # 32-bit checksum

    li      $v0, 4              # print string
    la      $a0, checksum32
    syscall

    li      $v0, 1              # print int
    move    $a0, $s4
    syscall

    li      $v0, 4              # print string
    la      $a0, new_line
    syscall

    # 8-bit XOR value

    li      $v0, 4              # print string
    la      $a0, xor_value8
    syscall

    move    $a0, $s5            # the number to print
    li      $a1, 6              # start digit offset (6 implies a byte)
    jal     print_hex

    # 16-bit XOR value

    li      $v0, 4              # print string
    la      $a0, xor_value16
    syscall

    move    $a0, $s6            # the number to print
    li      $a1, 4              # type: halfword
    jal     print_hex

    # 32-bit XOR value

    li      $v0, 4              # print string
    la      $a0, xor_value32
    syscall

    move    $a0, $s7            # the number to print
    li      $a1, 0              # type: word
    jal     print_hex

close:
    li      $v0, 16             # close file syscall
    lw      $a0, descriptor     # the file descriptor
    syscall

    b       get_filename       # loop to process another file (or exit)

# exit the program

exit:
    li      $v0, 10
    syscall

# subroutine to print hexadecimal number

    # $a0 => number to print
    # $a1 => start digit: 0=word, 4=halfword, 6=byte

print_hex:
    la      $t0, hex            # address to store the string representation of a hexadecimal number
    li      $t1, 28             # shift count (to the right) of the most significant hexadecimal digit

hex_loop:
289 srl     $t2, $a0, $t1       # get a value of a hexadecimal digit
    and     $t2, $t2, 0xf       # mask unused bits
    bgtu    $t2, 9, letter

    add     $t2, $t2, 0x30      # a digit 0-9, add 0x30 to get actual ASCII code
    b       next_hex

letter:
    add     $t2, $t2, 0x57      # a letter a-f, add ('a'-10) to get actual ASCII code

next_hex:
    sb      $t2, ($t0)          # store the digit
    add     $t0, $t0, 1         # advance the pointer
    sub     $t1, $t1, 4         # update the shift count (to get another digit)
    bgez    $t1, hex_loop

    li      $v0, 4              # print string
    la      $a0, hex_prefix
    syscall

    li      $v0, 4              # print string
    la      $a0, hex
    add     $a0, $a0, $a1
    syscall

    jr      $ra


    .data
filename:       .space 16       # input filename

descriptor:     .word 0         # input file descriptor
buffer:         .word 0         # input file buffer address

prompt:         .asciiz "\nEnter the file name: "
memory_error:   .asciiz "Memory error (sbrk syscall failed)\n"
open_error:     .asciiz "Cannot open file\n"
read_error:     .asciiz "Cannot read file\n"

checksum8:      .asciiz "8-bit checksum:    "
checksum16:     .asciiz "16-bit checksum:   "
checksum32:     .asciiz "32-bit checksum:   "
xor_value8:     .asciiz "8-bit XOR value:   "
xor_value16:    .asciiz "16-bit XOR value:  "
xor_value32:    .asciiz "32-bit XOR value:  "
new_line:       .asciiz "\n"

hex_prefix:     .asciiz "0x"
hex:            .asciiz "????????\n"

This is the code in MASM32:

    LOCAL   Kernel32:DWORD
    LOCAL   CreateFileA:DWORD
    LOCAL   GetFileSize:DWORD
    LOCAL   ReadFile:DWORD
    LOCAL   pBytesRead:DWORD
    LOCAL   BytesToRead:DWORD
    LOCAL   hFile:DWORD

    ;-----------------------------------------
    ;Getting Kernel Imagebase
    ;-----------------------------------------
    ;kernel32.dll = 2511EF2C
    PUSH    02511EF2Ch
    CALL    find_dll

    MOV Kernel32, EAX

    ;-----------------------------------------
    ;Find required APIs
    ;-----------------------------------------
    ;CreateFileA = 0CF2006EAh, GetFileSize = 06D61AB47h, ReadFile = 024EF6F37h, WriteFile = 0317EB0D7h

    PUSH    0CF2006EAh
    PUSH    Kernel32
    CALL    find_api

    MOV CreateFileA, EAX

    PUSH    06D61AB47h
    PUSH    Kernel32
    CALL    find_api

    MOV GetFileSize, EAX

    PUSH    024EF6F37h
    PUSH    Kernel32
    CALL    find_api

    MOV     ReadFile, EAX

    PUSH    NULL                                ; /hTemplateFile = NULL
    PUSH    FILE_ATTRIBUTE_NORMAL               ; |Attributes = FILE_ATTRIBUTE_NORMAL
    PUSH    OPEN_EXISTING                       ; |Mode = OPEN_EXISTING
    PUSH    0                                   ; |pSecurity = NULL
    PUSH    FILE_SHARE_READ + FILE_SHARE_WRITE  ; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE
    PUSH    GENERIC_ALL             ; |Access = GENERIC_ALL
    PUSH    FileName                ; |FileName = "*.exe"
    CALL    CreateFileA     ; \CreateFileA

    MOV hFile,EAX

    PUSH    0                       ; /pFileSizeHigh = NULL
    PUSH    hFile                   ; |hFile
    CALL    GetFileSize     ; \GetFileSize

    CMP EAX, 0h
    JZ  Exit

    MOV BytesToRead, 10h

    PUSH    0           ; /pOverlapped = NULL
        PUSH    pBytesRead      ; |pBytesRead = ?
    PUSH    BytesToRead     ; |BytesToRead
    PUSH    OFFSET Buffer       ; |Buffer
    PUSH    hFile           ; |hFile
    CALL    ReadFile        ; \ReadFile
Exit:

When debug it in Ollydbg it stops right here:

757F85EA   8907             MOV DWORD PTR DS:[EDI],EAX
EDI = 00000000
EAX = 00000055

And give me the error (described above) because EDI is 000000.

Why this error occurred and what is the solution to fix the problem?

;---------------------------------------------------------;
;reads a 64 bit integer from the consol and returns in rax;
;---------------------------------------------------------;
read_int:
    push rbx    ;these registers are nonvolitile and must be saved
    push rdi
    push rsi

    mov rsi, sint   ;load string address
    mov rdi, rsi    ;duplicat address
    add rdi, 21 ;shift to end of string
    .purge:     ;sets all string contents to null
    mov byte[rsi], 0;set byte to 0
    inc rsi     ;move to next byte
    cmp rsi, rdi    ;check if at end of string
    je .end_purge   ;exit loop if at end
    jmp .purge  ;loop

    .end_purge:

    mov rax, 3  ;system call code for read_string
    mov rbx, 0  ;where to read from.  in this case std_in
    mov rcx, sint   ;where the place the resultant string
    mov rdx, 21 ;how many characters to read
    int 0x80    ;system call

    mov rcx, 0  ;set registers rax, rbx, and rcx to 0
    mov rax, 0
    mov rbx, 0

    mov rsi, sint       ;load address of string into rsi and rdi
    mov rdi, sint
    add rdi, 21     ;shift rdi to the end of the string
    mov bl, byte[rsi]   ;load the first character in the string

    cmp rbx, 43 ;if charachter is + sign continue
    je .convert
    cmp rbx, 45 ;if character is - sign continue
    je .convert 

    sub rbx, 48 ;shift character to its literal value
    cmp rbx, 0  ;test if it is a number greator than 0
    jl .endr1   ;if not exit procedure
    cmp rbx, 9  ;test if it is a number less than 9
    jg .endr1   ;if not exit procedure
    add rax, rbx    ;if it is a valid number add it to the result.
    dec rdi     ;if first char is an integer we can only read 18 more
                ;so we need to shif rdi closer to start of string
                ;this way it will exit once we have read 19 total numbers

    ;does the actual conversion from string to number
    .convert:
        inc rsi         ;increment rsi to point to next byte

        cmp rsi, rdi        ;check if we are at the end of the string
        je .endr1

        mov bl, byte[rsi]   ;load next byte
        sub rbx, 48

        cmp rbx, 0      ;if this is not a valid number end procedure
        jl .endr1
        cmp rbx, 9      
        jg .endr1       

        mov rdx, 10
        mul rdx         ;multiply rax by 10 to make room for new ones place
        add rax, rbx        ;add the new number to the result
    jmp .convert

    .endr1:
    mov bl, byte[sint]  ;get first byte of integer string if minus do -result
    cmp rbx, 45
    jne .endr2

    not rax     ;convert rax to a negative
    inc rax     ;increment to get back to origional magnitude


.endr2:
pop rsi     ;restore saved values
pop rdi
pop rbx
ret         ;return to caller

;-----------------------------------------;
;prints the integer in rax to standard out;
;-----------------------------------------;
print_int:
    push rbx    ;save these registers as they are nonvolitile
    push rdi
    push rsi

    mov rsi, sint   ;load address to store string
    mov r10, 10 ;load divisor
    mov rcx, 0  ;clear registers
    mov rdx, 0

    mov rdi, rsi    ;copy address
    add rdi, 21 ;shift to end of space
    .purge:     ;make all bytes null same as above
    mov byte[rsi], 0
    inc rsi
    cmp rsi, rdi
    je .end_purge
    jmp .purge

    .end_purge:
    mov rsi, sint   ;restore origional values
    mov rdi, 0

    cmp rax, 0  ;compair the number to 0 
    jg .convert ;if its positive skip to convert
    jl .neg     ;if its negative skip to neg

    mov byte[rsi], 48   ;if its 0 add literal 0 to string
    jmp .endp1      ;jump to print
    .neg:

    not rax     ;take negation to make positive
    inc rax     ;increment to restore magnitude

    mov byte[rsi], 45   ;add the - sign to print string
    inc rsi         ;increment pointer

    .convert:
        cmp rax, 0  ;see if we are out of integers to convert
        je .converts    ;if so create string with chars
        inc rcx     ;increment counter

        div r10     ;divide by 10 placeing remainder in rdx and quotient in rax
        add rdx, 48 ;convert remainder to its char value

        mov r8,  rdx    ;move to r8
        push r8     ;push onto the stack
        mov rdx, 0  ;set rdx to 0

    jmp .convert    ;loop
    .converts:
        cmp rcx, 0  ;see if we are out of characters to concat
        je .endp1   ;if so go to print
        dec rcx     ;decrement counter

        pop rbx         ;pop a char
        mov byte[rsi], bl   ;concat char to string
        inc rsi         ;adjust string pointer to next empty slot

    jmp .converts   ;loop


    .endp1:
    mov rax, 4  ;system call code for print_string
    mov rbx, 1  ;print to std_out
    mov rcx, sint   ;address of string to print
    mov rdx, 20 ;number of chars to print
    int 0x80    ;system call

    pop rsi     ;restore saved values
    pop rdi
    pop rbx
ret

I also included my print procedure to make it easier to test the read procedure should you decide to run it.

Thanks.

here is my code:
print integer is just he control string %d as i am trying to read and wrint integers

        lea rax, print_int
        push rax
        push 10
        push 0
        call fgets
        pop rax
        pop rax
        pop rax

on a seperate note here is my attempt to use atoi:

        lea rax, x
        push rax
        call atoi

should i be adjusting the stack after calling functions?
what is the proper push order for fgets atoi and printf?
where do atoi and fgets place their results?
do pop and push automaticly adjust the stack?

Thanks

This program is supposed to take in a sentinel character and a maximum number of characters and then choose one of 4 options (counting the vowels, consonents, etc.). Whenever it starts counting though in "secPro:" it enters an endless loop where it compares the input character to god knows what (the value in the accumulator is odd). Please help.

# Lab 2 - GCD
#
    .data
A:  .word 0
B:  .word 0
Prompt: .asciiz "Type integer for A, press ENTER. Type integer for B, press ENTER \n"
Result: .asciiz "\nThe GCD is "

    .globl main
    .text

main:
    li $v0,4        # syscall to print String
    la $a0,Prompt       # load address of Prompt
    syscall         # print Prompt String

    li $v0,5        # syscall to read integer
    syscall         # read first intger
    move $a0,$v0        # move integer in $v0 to $a0

    li $v0,5        # syscall to read integer
    syscall         # read next integer
    move $a1,$v0        # move integer in $v0 to $a1

baseCase:
    bne $a1,$zero,recCase   # if $a1 != 0 branch to recCase
    li $v0,4        # syscall to print String
    la $a0,Result       # load address of Result
    syscall         # print result String

    lw $a0,A        # load A
    li $v0,1        # syscall to print integer
    syscall         # print A

    li $v0,10       # terminate prog running
    syscall         # return control to system

recCase:
    sub $sp,$sp,12      # push stack
    sw $ra,0($sp)       # save return address
    sw $a0,4($sp)       # save registers
    sw $a1,8($sp)       
    move $t0,$a1        # move $a1 to $t0
    rem $a1,$a0,$a1     # $a1 =  A%B
    sw $t0,A        # store A for output
    jal baseCase        # jump to baseCase

    lw $ra,0($sp)       # load main
    addi $sp,$sp,12     # 
    jr $ra          # return to main

encryption:
push eax
and eax,0xAA
not al
mov edx,eax
pop eax
and eax,0x55
xor ecx,edx
xor ecx,eax
rol cl,1
rol cl,1
mov eax,ecx
sub al,0x20

decryption:

add al, 0x20
mov eax, ecx
ror cl, 1
ror cl, 1
xor ecx, eax
xor ecx, edx
and eax, 0x55
pop eax
mov edx, eax
not al
and eax, 0xAA
push eax

I just thought that I'd put it out there. Anyone made something along these lines? Just curious to see what people may or may not have done.

What CPU is faster?Intel or amd (let's say both are 2Ghz processors. )

;+-+-+-+-+[ FileName: shellcode.asm ]+-+-+-+-+-+
.386
.model flat, stdcall
option casemap:none

;+-+-+-+-+ Include Files +-+-+-+-+-+
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc

;+-+-+-+-+ Include Libraries +-+-+-+-+
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib

.code
main:

;|=--------------=[ shell code section ]=---------------=|
    push 0 ; OK button
    jmp _caption
_rCaption:
    jmp _msg
_rMsg:
    push 0 ; hWnd
    call DWORD PTR DS:[402034h] ; <=> call MessageBox

    push 0
    call DWORD PTR DS:[402014h] ; <=> call ExitProcess

;|=--------------=[ shell data section ]=---------------=|
_caption:
    call _rCaption ; <=> push offset caption
    caption db "ha ha",0
_msg:
    call _rMsg ; <=> push offset msg
    msg db "You have been hacked!",0

end main

Now as you can see the routines above (messagebox, and exitprocess) are static, so I must know the address of the procedures inside the target program and put it into the shell and assemble it again!! :(

Is there any way to make the shell dynamically, my point is how to <b>include the dll procedures inside the body of programs?</b>

The reason of my question is to make the shell works in any program that have the stack buffer overflow vulnerability and maybe to make virus do the same way.

Note: I don't accept the solution that make the shell takes the addresses from import data section of the target program, this is can work for the example above but don't work with shells that have different dll procedures.

Any help would be great,
Thanks!

.386
.model flat, stdcall
option casemap :none 

include \masm32\include\windows.inc 
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc

includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib

WinMain PROTO :HINSTANCE, :HINSTANCE, :LPSTR, :DWORD
WinProc PROTO :HWND, :UINT, :WPARAM, :LPARAM

.data
    ClassName   db "MAIN_CLASS", 0
    MainTitle   db "A Window in Assembly!", 0
    ErrorText   db "Fatal Error, the program will now close...", 0
    ErrorTitle  db "Fatal Error", 0

.data?
    hInstance   HINSTANCE ?

.code
start:
    WinProc PROC hWnd:HWND, message:UINT, wParam:WPARAM, lParam:LPARAM
            cmp message, WM_DESTROY
            je DO_DESTROY

            cmp message, WM_CLOSE
            je DO_CLOSE

            jmp DO_DEFAULT

            DO_DESTROY:

            invoke PostQuitMessage, 0
            jmp DO_END

            DO_CLOSE:

            invoke DestroyWindow, addr hWnd
            jmp DO_END

            DO_DEFAULT:

            invoke DefWindowProc, hWnd, message, wParam, lParam
            ret
            jmp DO_STOP

            DO_END:

            xor eax, eax
            ret

            DO_STOP:

    WinProc ENDP

    WinMain PROC hInst:HINSTANCE, hPrevInst:HINSTANCE, CmdLine:LPSTR, CmdShow:DWORD
            local wc:WNDCLASSEX
            local msg:MSG
            local hWnd:HWND

            mov  wc.cbSize, SIZEOF WNDCLASSEX
            mov  wc.style, 0
            mov  wc.lpfnWndProc, offset WinProc
            mov  wc.cbClsExtra, NULL
            mov  wc.cbWndExtra, NULL
            push hInstance
            pop  wc.hInstance
            mov  wc.hbrBackground, COLOR_WINDOW + 1
            mov  wc.lpszMenuName, NULL
            mov  wc.lpszClassName, offset ClassName
            invoke LoadIcon, NULL, IDI_APPLICATION
            mov wc.hIcon, eax
            mov wc.hIconSm, eax
            invoke LoadCursor, NULL, IDC_ARROW
            mov wc.hCursor, eax
            invoke RegisterClassEx, addr wc
            cmp eax, 0
            je SHOW_ERROR

            invoke CreateWindowEx,
                WS_EX_CLIENTEDGE,
                addr ClassName,
                addr MainTitle,
                WS_OVERLAPPEDWINDOW,
                50,
                50,
                600,
                300,
                NULL,
                NULL,
                hInst,
                NULL
            mov hWnd, eax

            cmp hWnd, NULL
            je SHOW_ERROR

            invoke ShowWindow, hWnd, CmdShow
            invoke UpdateWindow, hWnd

            message_loop:

            invoke GetMessage, addr msg, addr hWnd, 0, 0
            cmp eax, 0
            je message_loop_end
            invoke TranslateMessage, addr msg
            invoke DispatchMessage, addr msg
            jmp message_loop

            message_loop_end:

            mov eax, msg.wParam
            ret

            jmp STOP

            SHOW_ERROR:

            invoke MessageBox, NULL, addr ErrorText, addr ErrorTitle, MB_OK
            jmp RET_ZERO

            RET_ZERO:

            mov eax, 0
            ret

            STOP:
    WinMain ENDP

    invoke GetModuleHandle, NULL
    mov hInstance, eax
    invoke WinMain, hInstance, NULL, NULL, 0
    invoke ExitProcess, eax
end start

Thanks again!

Okay so I made a program that add two numbers in 8085 AL but I keep getting 0A on C033 whatever I put in C031 AND C032. Help, please? Thanks!

Can someone help me to translate this in PEP/8 assembly language ? The rest of my program is functionning quite good, but I cant find a way to populate my matrix. Its a multidimension and variable length matrix, and I find this very complex. I know there is no such thing in assembly because multi dimension arrays are in fact one dimension arrays. I am quite lost.

To simplify I can say that no string will be more that 100 characters.

Thanks for any insight.

public static void LCS() {

    matrix = new int[String1Lenght + 1][String2Lenght + 1];
    for (int i = String1Lenght - 1; i >= 0; i--) {
        for (int j = String2Lenght - 1; j >= 0; j--) {
            if (String1Array[i] == String2Array[j]) {
                matrix[i][j] = matrix[i + 1][j + 1] + 1;

            } else {
                matrix[i][j] = max(matrix[i + 1][j], matrix[i][j + 1]);

            }
        }
    }
    int i = 0, j = 0;
    while (i < String1Lenght && j < String2Lenght) {
        if (String1Array[i] == String2Array[j]) {
            i++;
            j++;
        } else if (matrix[i + 1][j] >= matrix[i][j + 1]) {
            i++;
        } else {
            j++;
        }
    }

    System.out.print(j);
    System.out.println("");
}

In fact those don't even exist at the bit level.

Sure, they help solve some problems from all the way up to your compiled language syntax, but such symbols don't exist in machine code, which is logically simple, just, and basic in bulk of operations in the bit level(i.e. move this here, add this using two's complement, return this, compare that, do this if that, etc.).

So if we realize that the closer we get to the architecture the lesser the abstraction gets, and that our higher level data structures convert back to basic just machine instructions once they've solved some of our problems, why not just go bare basics and accomplish the implementation of these high level data structures more confined to the architecture itself, since, ultimately, that is what happens to our linguistics after we press F9?

If I were to right now develop a kernel keeping in tune with the underlying architecture, rather than being secure that my linked library invoking driver called subroutines and APIs right underneath my symbols are translated perfectly in to executable format images and/or specific file extensions I would expect to worry about the chip's implementation, not the behavior of APIs, drivers, and other platform handling modules and services, hence, I'd worry more about how my code is working directly, and I'd focus more on the bare basics of programming.

That is operating system development, as the only thing beneath me is mostly going to be hardware.

If I were to continue on being abstracted of the hardware by dozens of services, driver invoking libraries and APIs, and other combination of tools, utility software, compiling and linking software, and perfectly designated methods to invoke one thing on to the other, I'd eventually become so abstracted from the actual implementation of the architecture by the operating system as a whole, and eventually wouldn't know what I'd be writing code for due to such bloating abstraction from what code is really doing.

For example, I am not setting a pixel on the window system's client area on a GUI with my code I am calling a method through a binded language with a compatible language compiled library that will invoke a driver that will access a service that have a kernel handle everything for me ever so precisely through an executable image. How am I doing the full work though?

49 00 30
D1 00 30
1C
F1 00 33
51 00 33
zz

basically i just want a reference to help me understand assembly language like in OllyDBG.

Thanks.

basically i just want to figure out what all the PUSH MOV EAX stuff means and how to manipulate this and change these to edit certain values.

well basically are there any guides out there that teach you to read assembly language like the one in memory view of Cheat Enging or OllyDBG and preferably related more to hacking software.

Thanks.

I'm a student at a university and I'm having trouble with an assignment. Mainly because I am very new to assembly language.

If you have any experience using NASM x86 assembly language, please contact me through private messages

I am willing to pay well.

 org 0000h
Home:
mov r0,#00h
mov a,r0
lcall TT
mov p2,a
mov r1,#00h
mov a,r1
lcall TT
mov p3,a 
lcall delay

SEC1:
inc r0
mov a,r0
cjne a,#01h,L1
mov r0,#00h
sjmp SEC2

L1:
lcall TT
mov p2,a
lcall delay
sjmp SEC1

SEC2:
inc r1
mov a,r1
cjne a,#0ah,L2
mov r1,#00h
sjmp Home
L2:
lcall TT
mov p3,a
lcall delay
sjmp SEC2

TT:
cjne a,#01h,M1
mov a,#0F9h;1
ret
M1:
cjne a,#02h,M2
mov a,#0a4h;2
ret
M2:
cjne a,#03h,M3
mov a,#0b0h;3
ret
M3:
cjne a,#04h,M4
mov a,#099h;4
ret
M4:
cjne a,#05h,M5
mov a,#012h;5
ret
M5:
cjne a,#06h,M6
mov a,#082h;6
ret
M6:
cjne a,#07h,M7
mov a,#0f8h;7
ret
M7:
cjne a,#08h,M8
mov a,#080h;8
ret
M8:
cjne a,#09h,M9
mov a,#090h;9
ret
M9:
cjne a,#00h,M1
mov a,#0c0h;0
ret
M10:



delay: 
mov r2,#04h
mov r3,#080h
mov r4,#0ffh
djnz r4,$
djnz r3,$-2
djnz r2,$-4
ret
end