Practice exam says we hand grade code -- what does that mean?
Without a debugger, how do I debug my code in the exam?

    cc whatever.c thing2.c
    ./a.out
    
    cc -c *.c

pass by value vs pass by reference in C 
    C has no pass by reference
    always by value
    (but pointers are values)

2's complement of positive number
    2's complement means signed integer (in this class)
    0xxxxxxxxx => positive (or zero)
    1xxxxxxxxx => negative
    
    -x means
        1. reverse (swap 0 and 1) every bit (~)
        2. +1
    
    1000
    2^4 = 16 numbers
    -8 .. 0 .. +7
    
    1000000000000000
    0111111111111111 + 1
    1000000000000000
    
    0111001010011100
    
    1111001010011100                     = -3428
  -(0000110101100011 + 1)
  - 0000110101100100
        2048 + 1024 + 256 + 64 + 32 + 4  = 3428 

   10000000000000000
  - 1111001010011100
  ------------------
    0000110101100100

unsigned b-bit integer = between 0 and 2^b-1 inclusive
signed b-bit integer = between -2^(b-1) and 2^(b-1) - 1


bitwise operators, how to figure out what to use for operation
   x & 0x00fff000 == remove move bits (set them to 0)
   x >> 3         == move the bits
   x | y          == combine the bits (if x and y had non-overlapping bits at first)
   
   bit vector as a set
   | == union
   & == intersection


x >> 3 fills in with
    if x is signed, a copy of the "sign bit" (most significant)
    if x is unsigned, zeros

bitmasking
    is the x & 0x00ff00 from above
    
    (x >> 3) & 0x1fffffff
    
what does it mean to subtract one (bits HW)
    

in subtraction, do we carry/borrow?
    yes


endianness HW (pointers, bytes in memory, endianness)

segments of memory

    char *s = "hi";

    r/w global = non-const global variable
    r/o global = usually a string literal not saved to an array variable (or maybe a const global)
    r/o global = code
    
    
    int a[4];
    a[0]


safe vs unsafe memory access



undefined malloc

caches