# 8bit算術論理演算

<pre>
Note: 

サイクル数は<a href="../cycle.md#マシンサイクル">マシンサイクル</a>単位です。  
</pre>

## ADC A,r8

```
r8の値にキャリーを加えたものとAレジスタの値を足す  
処理結果はAレジスタに格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: bit7からオーバーフローした場合にセット
```

## ADC A,[HL]

```
HLが指すメモリアドレスの値にキャリーを加えたものとAレジスタの値を足す  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: bit7からオーバーフローした場合にセット
```

## ADC A,n8

```
n8にキャリーを加えたものとAレジスタの値を足す  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: bit7からオーバーフローした場合にセット
```

## ADD A,r8

```
r8の値とAレジスタの値を足す  
処理結果はAレジスタに格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: bit7からオーバーフローした場合にセット
```

## ADD A,[HL]

```
HLが指すメモリアドレスの値とAレジスタの値を足す  
処理結果はAレジスタに格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: bit7からオーバーフローした場合にセット
```

## ADD A,n8

```
n8とAレジスタの値を足す  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: bit7からオーバーフローした場合にセット
```

## AND A,r8

```
r8の値とAレジスタの値をAND  
処理結果はAレジスタに格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 1
    C: 0
```

## AND A,[HL]

```
HLが指すメモリアドレスの値とAレジスタの値をAND  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 1
    C: 0
```

## AND A,n8

```
n8とAレジスタの値をAND  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 1
    C: 0
```

## CP A,r8

```
Aレジスタからr8の値を引き、それに応じてフラグをセットする  
他の命令と違って、結果は(Aレジスタに)保存しない

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、r8 > A のとき)
```

## CP A,[HL]

```
AレジスタからHLが指すメモリアドレスの値を引き、それに応じてフラグをセットする  
他の命令と違って、結果は(Aレジスタに)保存しない

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、r8 > A のとき)
```

## CP A,n8

```
Aレジスタからn8を引き、それに応じてフラグをセットする  
他の命令と違って、結果は(Aレジスタに)保存しない

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、r8 > A のとき)
```

## DEC r8

```
r8の値をデクリメント(-1)する  
処理結果はr8に格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: 不変
```

## DEC [HL]

```
HLが指すメモリアドレスの値をデクリメント(-1)する  

サイクル: 3
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: 不変
```

## INC r8

```
r8の値をインクリメント(+1)する  
処理結果はr8に格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: 不変
```

## INC [HL]

```
HLが指すメモリアドレスの値をインクリメント(+1)する  

サイクル: 3
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: bit3からオーバーフローした場合にセット
    C: 不変
```

## OR A,r8

```
r8の値とAレジスタの値をOR  
処理結果はAレジスタに格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 0
    C: 0
```

## OR A,[HL]

```
HLが指すメモリアドレスの値とAレジスタの値をOR  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 0
    C: 0
```

## OR A,n8

```
n8とAレジスタの値をOR  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 0
    C: 0
```

## SBC A,r8

```
r8の値にキャリーを加えたものをAレジスタの値から引く
処理結果はAレジスタに格納される
A = A - (r8 + carry)

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、(r8+carry) > A のとき)
```

## SBC A,[HL]

```
HLが指すメモリアドレスの値にキャリーを加えたものをAレジスタの値から引く
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、([HL]+carry) > A のとき)
```

## SBC A,n8

```
n8にキャリーを加えたものをAレジスタの値から引く
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、(n8+carry) > A のとき)
```

## SUB A,r8

```
r8の値をAレジスタの値から引く
処理結果はAレジスタに格納される
A = A - r8

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、r8 > A のとき)
```

## SUB A,[HL]

```
HLが指すメモリアドレスの値をAレジスタの値から引く
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、[HL] > A のとき)
```

## SUB A,n8

```
n8をAレジスタの値から引く
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 1
    H: bit4からボローした場合にセット
    C: ボローした場合にセット(つまり、n8 > A のとき)
```

## XOR A,r8

```
r8の値とAレジスタの値をXOR  
処理結果はAレジスタに格納される

サイクル: 1
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 0
    C: 0
```

## XOR A,[HL]

```
HLが指すメモリアドレスの値とAレジスタの値をXOR  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 1
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 0
    C: 0
```

## XOR A,n8

```
n8とAレジスタの値をXOR  
処理結果はAレジスタに格納される

サイクル: 2
バイト長: 2
フラグ:
    Z: 結果が0ならセット
    N: 0
    H: 0
    C: 0
```