1. under WinDbg.exe go to File - Open Executable (CTRL+E) - a02.exe
2. at prompt set command:
bp 401000
or set other address that match exe start code
3. go to Debug - Go (F5)
4. now you are at 401000 and you can use F10 F11
use View - Command, Registers, Memory to see everything

usefull commands
bp   breakpoint
bp 401000
g   Go (F5)
db   dump memory
db 403000
r rdx 403008
db @rdx
eb   change memory
p   step
pa   step to address
pc   step to next call
r   display or modify register
r xmm4
r rax
r rcx=112
r xmm0:16ub, xmm1:d
t trace
ta trace to address
tc trace to next call
u unassemble


see help - Debuggers - Debugger Reference - Debugger Commands - Commands

see index - registers

----------

Calling Conventions

Unlike the x86, the C/C++ compiler only supports one calling convention on x64. This calling convention takes advantage of the increased number of registers available on x64:

The first four integer or pointer parameters are passed in the rcx, rdx, r8, and r9 registers.
The first four floating-point parameters are passed in the first four SSE registers, xmm0-xmm3. 
The caller reserves space on the stack for arguments passed in registers. The called function can use this space to spill the contents of registers to the stack. 
Any additional arguments are passed on the stack. 
An integer or pointer return value is returned in the rax register, while a floating-point return value is returned in xmm0. 
rax, rcx, rdx, r8-r11 are volatile. 
rbx, rbp, rdi, rsi, r12-r15 are nonvolatile. 

The calling convention for C++ is very similar: the this pointer is passed as an implicit first parameter. The next three parameters are passed in registers, while the rest are passed on the stack.

Addressing Modes
The addressing modes in 64-bit mode are similar to, but not identical to, x86.

Instructions that refer to 64-bit registers are automatically performed with 64-bit precision. (For example mov rax, [rbx] moves 8 bytes beginning at rbx into rax.) 
A special form of the mov instruction has been added for 64-bit immediate constants or constant addresses. For all other instructions, immediate constants or constant addresses are still 32 bits. 
x64 provides a new rip-relative addressing mode. Instructions that refer to a single constant address are encoded as offsets from rip. For example, the mov rax, [addr] instruction moves 8 bytes beginning at addr + rip to rax. 

Instructions, such as jmp, call, push, and pop, that implicitly refer to the instruction pointer and the stack pointer treat them as 64 bits registers on x64.

