# Python: 整数に上限なし（任意精度整数）
x = 2**64  # 18446744073709551616 — 問題なく扱える
x = 2**1000  # これも問題なし
 
# ただしctypesやstructで固定幅を扱う場合は制限あり
import struct
struct.pack('B', 255)   # uint8: OK
# struct.pack('B', 256)   # struct.error: ubyte format requires 0 <= number <= 255
 
# struct フォーマット文字
# 'B' = uint8,  'b' = int8
# 'H' = uint16, 'h' = int16
# 'I' = uint32, 'i' = int32
# 'Q' = uint64, 'q' = int64
 
# ctypes での固定幅整数
import ctypes
val = ctypes.c_uint8(255)
print(val.value)  # 255
val = ctypes.c_uint8(256)
print(val.value)  # 0 (ラップアラウンド)
 
# numpy での固定幅整数
import numpy as np
a = np.uint8(255)
print(a + np.uint8(1))  # 0 (ラップアラウンド、警告あり)

// Rust: 明示的な型指定が必須
let a: u8 = 255;    // OK
// let b: u8 = 256;    // コンパイルエラー！
let c: u32 = 4_294_967_295;  // OK (アンダースコアで視認性向上)
let d: u64 = 18_446_744_073_709_551_615;  // OK
 
// 型変換
let small: u8 = 200;
let large: u32 = small as u32;   // 安全な拡張（200のまま）
let back: u8 = large as u8;     // 切り捨て（200が戻る）
 
// u16 → u8 の切り捨て
let big: u16 = 300;
let truncated: u8 = big as u8;  // 300 - 256 = 44
 
// usize: プラットフォーム依存のサイズ（32ビットOS=32bit, 64ビットOS=64bit）
let index: usize = 42;  // 配列インデックスに使用

// Go: 明確な型システム
var a uint8 = 255
var b uint16 = 65535
var c uint32 = 4294967295
var d uint64 = 18446744073709551615
 
// uint: プラットフォーム依存（32 or 64ビット）
var e uint = 42
 
// byte は uint8 のエイリアス
var f byte = 0xFF
 
// 型変換は明示的
var g uint32 = uint32(a)  // uint8 → uint32
var h uint8 = uint8(b)    // uint16 → uint8（切り捨て）
 
// オーバーフローチェックはない（ラップアラウンド）
var i uint8 = 255
i++  // i = 0 (ラップアラウンド、エラーなし)
 
// math パッケージの定数
import "math"
fmt.Println(math.MaxUint8)   // 255
fmt.Println(math.MaxUint16)  // 65535
fmt.Println(math.MaxUint32)  // 4294967295

// JavaScript: Number型は64ビット浮動小数点
// → 安全に扱える整数の範囲は限定的
Number.MAX_SAFE_INTEGER  // 9007199254740991 (2^53 - 1)
Number.MIN_SAFE_INTEGER  // -9007199254740991
 
// 安全な範囲を超えると精度が失われる
console.log(9007199254740992 === 9007199254740993);  // true!（区別不可）
 
// BigInt で任意精度
const big = 18446744073709551615n;  // OK
const sum = big + 1n;  // 18446744073709551616n
 
// TypedArray で固定幅の符号なし整数
const u8 = new Uint8Array([255]);
const u16 = new Uint16Array([65535]);
const u32 = new Uint32Array([4294967295]);
 
// DataView でバイナリデータの読み書き
const buffer = new ArrayBuffer(4);
const view = new DataView(buffer);
view.setUint32(0, 0xDEADBEEF, true);  // true = リトルエンディアン
console.log(view.getUint8(0).toString(16));  // 'ef'

// C言語: 固定幅整数型（stdint.h 推奨）
#include <stdint.h>
#include <limits.h>
 
uint8_t  a = 255;           // 0 〜 255
uint16_t b = 65535;          // 0 〜 65535
uint32_t c = 4294967295U;   // 0 〜 4,294,967,295
uint64_t d = 18446744073709551615ULL;  // 0 〜 2^64-1
 
// size_t: メモリサイズ表現用（常に符号なし）
size_t len = sizeof(int);  // 4 or 8
 
// 伝統的な型（サイズはプラットフォーム依存で非推奨）
unsigned char      uc;    // 少なくとも8ビット
unsigned short     us;    // 少なくとも16ビット
unsigned int       ui;    // 少なくとも16ビット（通常32ビット）
unsigned long      ul;    // 少なくとも32ビット
unsigned long long ull;   // 少なくとも64ビット
 
// リテラルサフィックス
uint32_t x = 42U;      // unsigned
uint64_t y = 42ULL;    // unsigned long long

// Java: 符号なし整数型がない（Java 8以降で部分サポート）
 
// Java は全ての整数型が符号付き
byte  b = 127;     // -128 〜 127
short s = 32767;   // -32768 〜 32767
int   i = 2147483647;  // -2^31 〜 2^31-1
long  l = 9223372036854775807L;  // -2^63 〜 2^63-1
 
// Java 8以降: Integer/Long の符号なし演算メソッド
int unsigned = Integer.parseUnsignedInt("4294967295");  // 0xFFFFFFFF
String str = Integer.toUnsignedString(unsigned);  // "4294967295"
int result = Integer.divideUnsigned(unsigned, 2);  // 2147483647
int cmp = Integer.compareUnsigned(-1, 1);  // 正の値 (0xFFFFFFFF > 1)
 
// byte を符号なしとして扱う
byte byteVal = (byte) 0xFF;  // -1 として格納
int unsignedByte = byteVal & 0xFF;  // 255 として取得

# Pythonでの符号拡張シミュレーション
 
def sign_extend(value, from_bits, to_bits):
    """符号拡張: from_bits幅の符号付き整数をto_bits幅に拡張"""
    # 符号ビットを確認
    if value & (1 << (from_bits - 1)):
        # 負の数: 上位ビットを1で埋める
        mask = ((1 << to_bits) - 1) ^ ((1 << from_bits) - 1)
        return value | mask
    return value
 
# int8 → int32
print(sign_extend(0xFB, 8, 32))   # 0xFFFFFFFB = -5（32ビット）
print(sign_extend(0x05, 8, 32))   # 0x00000005 = +5（32ビット）
 
# 8ビット符号付き → Python整数
def int8_to_python(byte_val):
    """uint8値を符号付きint8として解釈"""
    if byte_val & 0x80:
        return byte_val - 256
    return byte_val
 
print(int8_to_python(0xFB))  # -5
print(int8_to_python(0x05))  # 5
print(int8_to_python(0x80))  # -128

# 有名なオーバーフロー事故
 
# 1. Ariane 5 ロケット爆発（1996年）
#    64ビット浮動小数点 → 16ビット符号付き整数への変換
#    水平速度が32,767を超え、オーバーフロー → 制御不能 → 爆発
#    損害: 5億ドル
 
# 2. パックマン 256面バグ（1980年）
#    面数を8ビット符号なし整数で管理
#    255面クリア → 256面 = 0x100 → 8ビットでは0x00
#    右半分が文字化けした「キルスクリーン」が出現
 
# 3. Boeing 787 電源喪失（2015年）
#    32ビットカウンタが248日で2^31に到達
#    int32オーバーフロー → 電源制御システムがシャットダウン
#    対策: 248日以内に再起動する暫定措置（！）
 
# 4. 2038年問題（Y2K38）
#    Unix時間: 1970年1月1日からの秒数（int32）
#    2^31 - 1 = 2,147,483,647秒 = 2038年1月19日 03:14:07 UTC
#    → int64への移行が必要
import time
# 2038年問題のタイムスタンプ
print(2**31 - 1)  # 2147483647
# ほとんどの現代システムは64ビットに移行済み
 
# 5. 文明シリーズの核ガンジー（都市伝説的だが有名）
#    ガンジーの攻撃性パラメータ(uint8)が1で、民主主義で-2されると
#    1 - 2 = -1 → uint8で255（最大値）になり超攻撃的に
#    ※ 実際にはバグではなく仕様だった可能性も指摘されている
 
# 6. ヒープバッファオーバーフロー（セキュリティ）
#    整数オーバーフローはバッファオーバーフロー攻撃の入り口になる
#    例: size_t size = user_input_width * user_input_height * 4;
#    巨大な width と height で乗算がオーバーフロー
#    → 小さなバッファが確保される
#    → 書き込み時にヒープ破壊 → 任意コード実行

# 有名なバイナリサーチのバグ（JDK 6で発見）
 
# ❌ 古典的な中間点計算（オーバーフローの可能性）
def binary_search_buggy(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2  # ← low + high がオーバーフローする可能性！
        # 例: low=2^30, high=2^30+100 → low+high > INT_MAX
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1
 
# ✅ 安全な中間点計算
def binary_search_safe(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = low + (high - low) // 2  # オーバーフロー安全
        # または: mid = (low + high) >>> 1  (Java/C#の符号なし右シフト)
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1
 
# ビット演算での安全な平均値計算
def safe_average(a, b):
    """オーバーフローなしの平均値"""
    return (a & b) + ((a ^ b) >> 1)
    # 共通ビット + 異なるビットの半分

# Python: 任意精度整数 → オーバーフローなし！
x = 2**100 + 1  # 問題なし
# Pythonは唯一、整数オーバーフローを心配しなくてよい言語
 
# ただし、ctypes/struct/numpy では固定幅なのでオーバーフローあり
import numpy as np
a = np.int8(127)
print(a + np.int8(1))  # -128 (ラップアラウンド)
 
# 安全な固定幅演算
def safe_add_int32(a, b):
    """Pythonでint32のオーバーフローをシミュレート"""
    result = a + b
    if result > 2**31 - 1 or result < -(2**31):
        raise OverflowError(f"int32 overflow: {a} + {b} = {result}")
    return result

// Rust: コンパイル時・実行時の検出
let x: u8 = 255;
 
// デバッグビルド: パニック（プログラム停止）
// let y = x + 1;  // thread 'main' panicked at 'attempt to add with overflow'
 
// リリースビルド: ラップアラウンド（デフォルト）
// 明示的なオーバーフロー制御メソッド:
let a = x.checked_add(1);    // Option<u8> → None
let b = x.saturating_add(1); // 255 (上限で飽和)
let c = x.wrapping_add(1);   // 0 (明示的ラップ)
let d = x.overflowing_add(1); // (0, true) — 値とオーバーフローフラグ
 
// 実務での使い分け:
// checked_add: 正確性が最重要（金融、科学計算）
// saturating_add: 上限/下限で止まるのが望ましい（音量、明度）
// wrapping_add: ラップアラウンドが仕様（ハッシュ、カウンタ）
// overflowing_add: オーバーフローの発生を知りたい（低レベルCPU模倣）
 
// saturating の実用例
fn adjust_volume(current: u8, delta: i8) -> u8 {
    if delta >= 0 {
        current.saturating_add(delta as u8)
    } else {
        current.saturating_sub((-delta) as u8)
    }
}
// adjust_volume(250, 10) → 255（255で飽和）
// adjust_volume(5, -10) → 0（0で飽和）

// Java: サイレントラップアラウンド（危険！）
int x = Integer.MAX_VALUE;  // 2147483647
int y = x + 1;              // -2147483648 (警告なし！)
 
// Java 8以降: Math.addExact()
try {
    int z = Math.addExact(x, 1);  // ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Overflow detected!");
}
 
// Math クラスの安全な演算メソッド
Math.addExact(a, b);       // 加算（オーバーフロー時例外）
Math.subtractExact(a, b);  // 減算
Math.multiplyExact(a, b);  // 乗算
Math.negateExact(a);       // 否定
Math.incrementExact(a);    // +1
Math.decrementExact(a);    // -1
Math.toIntExact(longVal);  // long → int（範囲外で例外）

// C: 符号付きオーバーフローは未定義動作（最も危険）
int x = INT_MAX;
int y = x + 1;  // 未定義動作！コンパイラが何をしても「正しい」
// GCCの最適化により、オーバーフローチェックが削除される場合もある
 
// 安全な加算チェック（符号付き）:
#include <limits.h>
#include <stdbool.h>
 
bool safe_add_int(int a, int b, int *result) {
    if (b > 0 && a > INT_MAX - b) return false;  // オーバーフロー
    if (b < 0 && a < INT_MIN - b) return false;  // アンダーフロー
    *result = a + b;
    return true;
}
 
// 安全な乗算チェック（符号付き）:
bool safe_mul_int(int a, int b, int *result) {
    if (a == 0 || b == 0) {
        *result = 0;
        return true;
    }
    if (a > 0 && b > 0 && a > INT_MAX / b) return false;
    if (a > 0 && b < 0 && b < INT_MIN / a) return false;
    if (a < 0 && b > 0 && a < INT_MIN / b) return false;
    if (a < 0 && b < 0 && a < INT_MAX / b) return false;
    *result = a * b;
    return true;
}
 
// GCC/Clang ビルトイン:
int result;
if (__builtin_add_overflow(a, b, &result)) {
    // オーバーフロー発生
}
if (__builtin_mul_overflow(a, b, &result)) {
    // オーバーフロー発生
}

// Go: サイレントラップアラウンド（Javaと同様）
package main
 
import (
    "fmt"
    "math"
)
 
func main() {
    var x int32 = math.MaxInt32  // 2147483647
    x++  // -2147483648 (ラップアラウンド、エラーなし)
    fmt.Println(x)
 
    // 安全な加算
    a, b := int32(2000000000), int32(1000000000)
    if safeAddInt32(a, b) {
        fmt.Println("OK:", a+b)
    } else {
        fmt.Println("Overflow!")
    }
}
 
func safeAddInt32(a, b int32) bool {
    if b > 0 && a > math.MaxInt32-b {
        return false
    }
    if b < 0 && a < math.MinInt32-b {
        return false
    }
    return true
}

import struct
 
value = 0x12345678
 
# ビッグエンディアンでパック
big = struct.pack('>I', value)
print(big.hex())  # '12345678'
 
# リトルエンディアンでパック
little = struct.pack('<I', value)
print(little.hex())  # '78563412'
 
# ネットワーク通信での注意:
# ネットワーク = ビッグエンディアン
# x86 PC = リトルエンディアン
# → 送受信時にバイトオーダー変換が必要
 
import socket
# ホストバイトオーダー → ネットワークバイトオーダー
port = 8080
network_port = socket.htons(port)  # host to network short
 
ip = 0xC0A80001  # 192.168.0.1
network_ip = socket.htonl(ip)  # host to network long
 
# バイトスワップのビット演算実装
def bswap32(n):
    return ((n & 0xFF000000) >> 24) | \
           ((n & 0x00FF0000) >> 8) | \
           ((n & 0x0000FF00) << 8) | \
           ((n & 0x000000FF) << 24)
 
def bswap16(n):
    return ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8)
 
print(hex(bswap32(0x12345678)))  # 0x78563412
print(hex(bswap16(0x1234)))      # 0x3412

import sys
print(sys.byteorder)  # 'little' (x86/ARM) or 'big'
 
# バイナリファイルの先頭を見て判断する例:
# BMP画像: 先頭が 'BM' (0x42 0x4D) → リトルエンディアン
# JPEG: 先頭が 0xFF 0xD8 → エンディアン非依存
# ELF: offset 5 に 1(LE) or 2(BE) が格納
# UTF-16 BOM: 0xFE 0xFF(BE) or 0xFF 0xFE(LE)
 
# エンディアン判定の実用コード
def detect_endianness():
    """実行環境のエンディアンを判定"""
    import struct
    if struct.pack('@I', 1) == struct.pack('<I', 1):
        return 'little'
    else:
        return 'big'

# 実務: バイナリプロトコルの設計と実装
 
import struct
 
# パケットヘッダの例（ネットワークバイトオーダー = ビッグエンディアン）
class PacketHeader:
    FORMAT = '>HHI'  # ビッグエンディアン: uint16 type, uint16 length, uint32 sequence
    SIZE = struct.calcsize(FORMAT)
 
    def __init__(self, msg_type, length, sequence):
        self.msg_type = msg_type
        self.length = length
        self.sequence = sequence
 
    def pack(self):
        return struct.pack(self.FORMAT, self.msg_type, self.length, self.sequence)
 
    @classmethod
    def unpack(cls, data):
        msg_type, length, sequence = struct.unpack(cls.FORMAT, data[:cls.SIZE])
        return cls(msg_type, length, sequence)
 
# 使用例
header = PacketHeader(msg_type=1, length=100, sequence=42)
packed = header.pack()
print(packed.hex())  # '0001006400000002a'
 
# 受信側
received = PacketHeader.unpack(packed)
print(f"Type: {received.msg_type}, Len: {received.length}, Seq: {received.sequence}")
 
 
# バイナリファイルフォーマットの例
class BMPHeader:
    """BMP画像ヘッダ（リトルエンディアン）"""
    FORMAT = '<2sIHHI'  # リトルエンディアン: signature, filesize, reserved1, reserved2, data_offset
 
    @classmethod
    def read(cls, filepath):
        with open(filepath, 'rb') as f:
            data = f.read(struct.calcsize(cls.FORMAT))
            sig, size, r1, r2, offset = struct.unpack(cls.FORMAT, data)
            return {
                'signature': sig,  # b'BM'
                'filesize': size,
                'data_offset': offset
            }

# 固定小数点数ライブラリの実装
 
class FixedPoint:
    """Q16.16 固定小数点数"""
    FRAC_BITS = 16
    SCALE = 1 << FRAC_BITS  # 65536
    MASK = (1 << 32) - 1     # 32ビットマスク
 
    def __init__(self, value=0):
        if isinstance(value, float):
            self._raw = int(value * self.SCALE)
        elif isinstance(value, int):
            self._raw = value * self.SCALE
        else:
            raise TypeError(f"Unsupported type: {type(value)}")
 
    @classmethod
    def from_raw(cls, raw):
        """内部値から直接生成"""
        obj = cls.__new__(cls)
        obj._raw = raw
        return obj
 
    def to_float(self):
        return self._raw / self.SCALE
 
    def __add__(self, other):
        return FixedPoint.from_raw(self._raw + other._raw)
 
    def __sub__(self, other):
        return FixedPoint.from_raw(self._raw - other._raw)
 
    def __mul__(self, other):
        # 乗算後に小数部ビット数分右シフト
        return FixedPoint.from_raw((self._raw * other._raw) >> self.FRAC_BITS)
 
    def __truediv__(self, other):
        # 被除数を左シフトしてから除算
        return FixedPoint.from_raw((self._raw << self.FRAC_BITS) // other._raw)
 
    def __repr__(self):
        return f"FixedPoint({self.to_float():.6f})"
 
    def __eq__(self, other):
        return self._raw == other._raw
 
# 使用例
a = FixedPoint(3.75)
b = FixedPoint(2.0)
print(a + b)      # FixedPoint(5.750000)
print(a - b)      # FixedPoint(1.750000)
print(a * b)      # FixedPoint(7.500000)
print(a / b)      # FixedPoint(1.875000)

# ❌ 浮動小数点で金額計算（危険！）
price = 0.1 + 0.2
print(price)  # 0.30000000000000004
print(price == 0.3)  # False!
 
# ✅ 整数（セント単位）で金額計算
price_cents = 10 + 20  # 30セント
print(price_cents / 100)  # 0.3
 
# ✅ Decimal型を使用
from decimal import Decimal, ROUND_HALF_UP
price = Decimal('0.1') + Decimal('0.2')
print(price)  # 0.3
print(price == Decimal('0.3'))  # True
 
# 通貨計算のベストプラクティス
class Money:
    """整数ベースの金額表現"""
 
    def __init__(self, amount_cents):
        self._cents = int(amount_cents)
 
    @classmethod
    def from_string(cls, s):
        """'1234.56' → Money(123456)"""
        d = Decimal(s) * 100
        return cls(int(d))
 
    @classmethod
    def from_float(cls, f):
        """浮動小数点から（非推奨だが必要な場合）"""
        return cls(round(f * 100))
 
    def __add__(self, other):
        return Money(self._cents + other._cents)
 
    def __sub__(self, other):
        return Money(self._cents - other._cents)
 
    def __mul__(self, factor):
        """金額 × 数量"""
        result = Decimal(self._cents) * Decimal(str(factor))
        return Money(int(result.quantize(Decimal('1'), rounding=ROUND_HALF_UP)))
 
    def __repr__(self):
        sign = '-' if self._cents < 0 else ''
        abs_cents = abs(self._cents)
        return f"¥{sign}{abs_cents // 100}.{abs_cents % 100:02d}"
 
# 使用例
item = Money.from_string('1980')     # ¥1980.00
tax = item * Decimal('0.1')          # ¥198.00
total = item + tax                    # ¥2178.00
print(total)                          # ¥2178.00
 
 
# ✅ 実務でのベストプラクティス
# データベース: DECIMAL(10, 2) — 整数部10桁、小数部2桁
# JavaScript: 金額は全てセント(整数)で扱い、表示時のみ変換
# Java: BigDecimal を使用
# Python: decimal.Decimal を使用

// C言語の暗黙の型変換（整数昇格）
 
// 1. 整数昇格: int より小さい型は int に変換される
uint8_t a = 200;
uint8_t b = 100;
uint8_t c = a + b;  // 200 + 100 = 300 → int(300) → uint8(44)
// a, b は int に昇格されて加算、結果が uint8 に切り捨て
 
// 2. 符号付きと符号なしの混合演算
int x = -1;
unsigned int y = 1;
if (x < y) {
    printf("x < y\n");  // 期待する出力
} else {
    printf("x >= y\n");  // 実際にはこちら！
}
// -1 は unsigned int に変換 → 0xFFFFFFFF = 4294967295 > 1
 
// 3. 比較時の暗黙変換
int len = -1;
if (len < sizeof(int)) {
    // sizeof は size_t（符号なし）を返す
    // len(-1) が size_t に変換 → 巨大な正の値
    // → この条件は false になる！
}
 
// 安全なパターン
if (len >= 0 && (size_t)len < sizeof(int)) {
    // 先に負の値チェック
}

# Pythonでの型変換の注意点
 
# Python 3 の // 演算子（切り捨て除算）
print(7 // 2)     # 3 (正の数は切り捨て)
print(-7 // 2)    # -4 (負の無限大方向への切り捨て)
# C言語の -7 / 2 = -3 (ゼロ方向への切り捨て) とは異なる!
 
# Python 3 の % 演算子（剰余）
print(7 % 2)      # 1
print(-7 % 2)     # 1 (Pythonの剰余は常に除数と同符号)
# C言語の -7 % 2 = -1 とは異なる!
 
# int から bool
bool(0)    # False
bool(1)    # True
bool(-1)   # True (0以外は全てTrue)
 
# bool から int
int(True)  # 1
int(False) # 0
True + True  # 2 (boolはintのサブクラス)

unsigned int a = 1;
int b = -1;
printf("%d\n", a > b);  // ???
printf("%u\n", b);       // ???

# 演習1 解答
 
# 1. -42 のビット表現（8ビット2の補数）
# +42 = 0010 1010
# 反転 = 1101 0101
# +1  = 1101 0110 = 0xD6 = -42
print(f"-42 = {(-42) & 0xFF:08b} = 0x{(-42) & 0xFF:02X}")
# -42 = 11010110 = 0xD6
 
# 2. 50 + (-30) の加算
#   0011 0010 (50)
# + 1110 0010 (-30)
# = 1 0001 0100 → キャリーを捨てて → 0001 0100 = 20 ✓
print(f"50 + (-30) = {(50 + (-30)) & 0xFF}")
# 50 + (-30) = 20
 
# 3. -100 + (-50) の加算
# -100 = 1001 1100 (0x9C)
# -50  = 1100 1110 (0xCE)
#   1001 1100
# + 1100 1110
# = 1 0110 1010 → キャリーを捨てて → 0110 1010 = 106
# 負 + 負 = 正 → オーバーフロー！（-150は8ビット符号付きの範囲外）
result = ((-100) & 0xFF) + ((-50) & 0xFF)
print(f"-100 + (-50) = {result & 0xFF} (unsigned), interpreted as {result & 0xFF if result & 0xFF < 128 else (result & 0xFF) - 256}")
# → 106 (正の値) = オーバーフロー（正しい結果は-150）
 
 
# 演習2 解答
def will_overflow_int32(a, b):
    """32ビット符号付き整数の加算がオーバーフローするか判定"""
    INT32_MAX = 2**31 - 1   # 2147483647
    INT32_MIN = -(2**31)    # -2147483648
 
    if b > 0 and a > INT32_MAX - b:
        return True  # 正のオーバーフロー
    if b < 0 and a < INT32_MIN - b:
        return True  # 負のオーバーフロー
    return False
 
# テスト
print(will_overflow_int32(2**31 - 1, 1))      # True
print(will_overflow_int32(2**31 - 1, 0))      # False
print(will_overflow_int32(-(2**31), -1))       # True
print(will_overflow_int32(100, -50))           # False
 
 
# 演習3 解答
import struct
 
def read_as_both_endian(data):
    """4バイトを両エンディアンで解釈"""
    le_value = struct.unpack('<I', data)[0]
    be_value = struct.unpack('>I', data)[0]
    le_signed = struct.unpack('<i', data)[0]
    be_signed = struct.unpack('>i', data)[0]
 
    print(f"Bytes: {data.hex()}")
    print(f"Little-Endian unsigned: {le_value} (0x{le_value:08X})")
    print(f"Big-Endian unsigned:    {be_value} (0x{be_value:08X})")
    print(f"Little-Endian signed:   {le_signed}")
    print(f"Big-Endian signed:      {be_signed}")
 
# テスト
read_as_both_endian(b'\x12\x34\x56\x78')
# Bytes: 12345678
# Little-Endian unsigned: 2018915346 (0x78563412)
# Big-Endian unsigned:    305419896 (0x12345678)
# Little-Endian signed:   2018915346
# Big-Endian signed:      305419896
 
 
# 演習4 解答
class Q8_8:
    """Q8.8固定小数点数"""
    FRAC = 8
    SCALE = 256
 
    def __init__(self, value):
        if isinstance(value, float):
            self._raw = int(value * self.SCALE)
        else:
            self._raw = value * self.SCALE
 
    @classmethod
    def _from_raw(cls, raw):
        obj = cls.__new__(cls)
        obj._raw = raw
        return obj
 
    def to_float(self):
        return self._raw / self.SCALE
 
    def __add__(self, other):
        return Q8_8._from_raw(self._raw + other._raw)
 
    def __mul__(self, other):
        return Q8_8._from_raw((self._raw * other._raw) >> self.FRAC)
 
    def __truediv__(self, other):
        return Q8_8._from_raw((self._raw << self.FRAC) // other._raw)
 
    def __repr__(self):
        return f"Q8.8({self.to_float():.4f})"
 
a = Q8_8(3.14)
b = Q8_8(2.71)
print(f"3.14 + 2.71 = {(a + b)} (float: {3.14 + 2.71})")
print(f"3.14 * 2.71 = {(a * b)} (float: {3.14 * 2.71})")
c = Q8_8(10.0)
d = Q8_8(3.0)
print(f"10.0 / 3.0 = {(c / d)} (float: {10.0 / 3.0})")
# 固定小数点は精度が限られるため、float との微小な差が生じる
 
 
# 演習5 解答
# unsigned int a = 1;
# int b = -1;
# printf("%d\n", a > b);
# → 出力: 0 (false)
# → bがunsigned intに変換され、-1は4294967295になる
# → 1 > 4294967295 は false
 
# printf("%u\n", b);
# → 出力: 4294967295
# → -1のビットパターン(0xFFFFFFFF)をunsignedとして解釈

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]