```Machine instructions generally fall into three categories: data movement, arithmetic/logic, and control-flow. In this section, we will look at important examples of x86 instructions from each category. This section should not be considered an exhaustive list of x86 instructions, but rather a useful subset. For a complete list, see Intel's instruction set reference.
We use the following notation:
<reg32>        Any 32-bit register (EAX, EBX, ECX, EDX, ESI, EDI, ESP, or EBP)
<reg16>    Any 16-bit register (AX, BX, CX, or DX)
<reg8>    Any 8-bit register (AH, BH, CH, DH, AL, BL, CL, or DL)
<reg>    Any register
<mem>    A memory address (e.g., [eax], [var + 4], or dword ptr [eax+ebx])
<con32>    Any 32-bit constant
<con16>    Any 16-bit constant
<con8>    Any 8-bit constant
<con>    Any 8-, 16-, or 32-bit constant
```

```Some examples of mov instructions using address computations are:
mov eax, [ebx]    ; Move the 4 bytes in memory at the address contained in EBX into EAX
mov [var], ebx    ; Move the contents of EBX into the 4 bytes at memory address var. (Note, var is a 32-bit constant).
mov eax, [esi-4]    ; Move 4 bytes at memory address ESI + (-4) into EAX
mov [esi+eax], cl    ; Move the contents of CL into the byte at address ESI+EAX
mov edx, [esi+4*ebx]        ; Move the 4 bytes of data at address ESI+4*EBX into EDX
```

```Modern (i.e 386 and beyond) x86 processors have eight 32-bit general purpose registers, as depicted in Figure 1. The register names are mostly historical. For example, EAX used to be called the accumulator since it was used by a number of arithmetic operations, and ECX was known as the counter since it was used to hold a loop index. Whereas most of the registers have lost their special purposes in the modern instruction set, by convention, two are reserved for special purposes — the stack pointer (ESP) and the base pointer (EBP).

For the EAX, EBX, ECX, and EDX registers, subsections may be used. For example, the least significant 2 bytes of EAX can be treated as a 16-bit register called AX. The least significant byte of AX can be used as a single 8-bit register called AL, while the most significant byte of AX can be used as a single 8-bit register called AH. These names refer to the same physical register. When a two-byte quantity is placed into DX, the update affects the value of DH, DL, and EDX. These sub-registers are mainly hold-overs from older, 16-bit versions of the instruction set. However, they are sometimes convenient when dealing with data that are smaller than 32-bits (e.g. 1-byte ASCII characters).
```

```long a = 0; 

Thread thread1 = new Thread() {
    a = 100;
}

Thread thread2 = new Thread() {
   System.out.println(a + 1);
}
```

```T[] a = new T[10];
a[0] = 0;
a[1] = 0;

Thread t1 = new Thread() {
    a[0] = 10;
}

Thread t2 = new Thread() {
   System.out.println(a[1])
}
```