ripple-carry:~
32 full adders plus 1 xor
32*(3*and2+or3+2*xor2)+xor2
32*(6+3+6)+3
32*(15)+3
480+3
483 area units

carry-lookahead:
*note* there is a little wasted logic to support
       carryout for 16 and 4 bit adders, though
       we don't currently use those couts.
32 adds:
and4 and4 and2 and2 and3 and3 and4 and4 OR4 OR4 and2 and3 or2 or3
4+4+2+2+3+3+4+4+4+4+2+3+2+3 = 44

each 16 adds:
and4 and4 and4 and4 and2 and2 and2 and2 and3 and3 and3 and3 and4 and4 and4 and4 or4 or4 or4 or4
and2 and2 and2 and2 and3 and3 and3 and4 and4 and2 or2 or3 or4 or3 or2 or2
4+4+4+4+2+2+2+2+3+3+3+3+4+4+4+4+4+4+4+4+2+2+2+2+3+3+3+4+4+2+3+4+3+2+2 = 109

each 4 adds:
8+8+2+2+2+2+3+3+3+4+4+2+2+3+4 = 52

each summer adds:
xor2 xor2 = 6

total = 32*6+8*52+2*109+44+3 = 873 area units

-------------------------------------------------------------------------

ripplecarry:
cout takes and2 + or3
31 (and2+or3) to get last cin, then sum delay
31*7+2*5+5 = 232 time units

lookahead:

the 16-bit can start its work after each pi and gi are ready (1 2-input delay)
the 16-bit takes an and4 to get its pi
the 16-bit takes an or4, and4 to get its gi
total penalty to 16-bit gi: 1 2-input, or4, and4
32-bit can start its work after the 16-bits get pi/gi
the 32-bit takes an and4 to get its pi
the 32-bit takes an or4, and4 to get its gi
penalty to 32-bit gi: 1 2-input, or4, and4, or4, and4 = 3+5+5+5+5 = 23
penatly to cout: or3 + and3 + 23 = 4+4+23 = 31
penalty to c1: or2 + and2 + 23 = 3+3+23 = 29

penalty to highest 4-bit cin: 29 + or4 + and4 = 29+5+5 = 39
penalty to last cin: 39+or4+and4 = 39+5+5=49
penalty to sum: 49+xor+xor = 59

sum slower than last cin xor cout, so crit path = 59

quite clearly, the lookahead is 232/59x faster (3.9x faster)

--------------------------------------------------------

ripple-carry will be 95*7+2 = 667 time units
lookahead (96): another pi and gi delay, then the 96 can start its work, and it will have the last 32 ready after another c delay, total of or3 or4 and3 and4 = 18 extra = 77 time units
barrel shifter: instead of 5 rows of mux2s, followed by another mux2, it would go to 7 rows, then a final mux2.
		mux2 takes and or = 6, so instead of 6*6 = 36, 8*6 = 48