FullAdder

CHIP FullAdder {
    IN a, b, c;  // 1-bit inputs
    OUT sum,     // Right bit of a + b + c
        carry;   // Left bit of a + b + c

    PARTS:
    // Put you code here:

    Xor(a=a,b=b,out=d);
    Xor(a=c,b=d,out=sum);

    And(a=a,b=b,out=ab);
    And(a=a,b=c,out=ac);
    And(a=b,b=c,out=bc);

    Or(a=ab,b=ac,out=abORac);
    Or(a=abORac,b=bc,out=carry);
}

HalfAdder

CHIP HalfAdder {
    IN a, b;    // 1-bit inputs
    OUT sum,    // Right bit of a + b 
        carry;  // Left bit of a + b

    PARTS:
    // Put you code here:
    Xor(a=a,b=b,out=sum);
    And(a=a,b=b,out=carry);
}

Add16

CHIP Add16 {
    IN a[16], b[16];
    OUT out[16];

    PARTS:
   // Put you code here:
   FullAdder(a=a[0],b=b[0],sum=out[0],carry=c1);
   FullAdder(a=a[1],b=b[1],c=c1,sum=out[1],carry=c2);
   FullAdder(a=a[2],b=b[2],c=c2,sum=out[2],carry=c3);
   FullAdder(a=a[3],b=b[3],c=c3,sum=out[3],carry=c4);
   FullAdder(a=a[4],b=b[4],c=c4,sum=out[4],carry=c5);
   FullAdder(a=a[5],b=b[5],c=c5,sum=out[5],carry=c6);
   FullAdder(a=a[6],b=b[6],c=c6,sum=out[6],carry=c7);
   FullAdder(a=a[7],b=b[7],c=c7,sum=out[7],carry=c8);
   FullAdder(a=a[8],b=b[8],c=c8,sum=out[8],carry=c9);
   FullAdder(a=a[9],b=b[9],c=c9,sum=out[9],carry=c10);
   FullAdder(a=a[10],b=b[10],c=c10,sum=out[10],carry=c11);
   FullAdder(a=a[11],b=b[11],c=c11,sum=out[11],carry=c12);
   FullAdder(a=a[12],b=b[12],c=c12,sum=out[12],carry=c13);
   FullAdder(a=a[13],b=b[13],c=c13,sum=out[13],carry=c14);
   FullAdder(a=a[14],b=b[14],c=c14,sum=out[14],carry=c15);
   FullAdder(a=a[15],b=b[15],c=c15,sum=out[15]);
}

Inc16

CHIP Inc16 {
    IN in[16];
    OUT out[16];

    PARTS:
   // Put you code here:
   //Not(in=in[0],out=neg);
   //Or(a=in[0],b=neg,out=one);

   HalfAdder(a=in[0],b=true,sum=out[0],carry=c1);
   HalfAdder(a=in[1],b=c1,sum=out[1],carry=c2);
   HalfAdder(a=in[2],b=c2,sum=out[2],carry=c3);
   HalfAdder(a=in[3],b=c3,sum=out[3],carry=c4);
   HalfAdder(a=in[4],b=c4,sum=out[4],carry=c5);
   HalfAdder(a=in[5],b=c5,sum=out[5],carry=c6);
   HalfAdder(a=in[6],b=c6,sum=out[6],carry=c7);
   HalfAdder(a=in[7],b=c7,sum=out[7],carry=c8);
   HalfAdder(a=in[8],b=c8,sum=out[8],carry=c9);
   HalfAdder(a=in[9],b=c9,sum=out[9],carry=c10);
   HalfAdder(a=in[10],b=c10,sum=out[10],carry=c11);
   HalfAdder(a=in[11],b=c11,sum=out[11],carry=c12);
   HalfAdder(a=in[12],b=c12,sum=out[12],carry=c13);
   HalfAdder(a=in[13],b=c13,sum=out[13],carry=c14);
   HalfAdder(a=in[14],b=c14,sum=out[14],carry=c15);
   HalfAdder(a=in[15],b=c15,sum=out[15]);
}

ALU

CHIP ALU {
IN
x[16], y[16], // 16-bit inputs
zx, // zero the x input?
nx, // negate the x input?
zy, // zero the y input?
ny, // negate the y input?
f, // compute out = x + y (if 1) or x & y (if 0)
no; // negate the out output?

OUT
out[16], // 16-bit output
zr, // 1 if (out == 0), 0 otherwise
ng; // 1 if (out < 0), 0 otherwise

PARTS:
// Put you code here:
//zx ng
Mux16(a=x,b=false,sel=zx,out=x1);
Not16(in=x1,out=notx);
Mux16(a=x1,b=notx,sel=nx,out=ndx);
//zy ny
Mux16(a=y,b=false,sel=zy,out=y1);
Not16(in=y1,out=noty);
Mux16(a=y1,b=noty,sel=ny,out=ndy);
//相加，相乘
Add16(a=ndx,b=ndy,out=addxy);
And16(a=ndx,b=ndy,out=andxy);
//f
Mux16(a=andxy,b=addxy,sel=f,out=fout);
Not16(in=fout,out=nfout);
//no,ng
Mux16(a=fout,b=nfout,sel=no,out=out,out[0..7]=or07,out[8..15]=or815,out[15]=ng);
//zr
Or8Way(in=or07,out=zr1);
Or8way(in=or815,out=zr2);
Or(a=zr1,b=zr2,out=ornego);
Not(in=ornego,out=zr);
}