reg_add.map.eqn

自己用VHDL写的并行乘法累加和元算

--sum101[5] is sum101[5]
sum101[5] = A1L552 & A1L111 # !A1L552 & (sum101[5]);


--sum102[4] is sum102[4]
sum102[4] = A1L552 & A1L98 # !A1L552 & (sum102[4]);


--sum101[4] is sum101[4]
sum101[4] = A1L552 & A1L901 # !A1L552 & (sum101[4]);


--sum102[3] is sum102[3]
sum102[3] = A1L552 & A1L78 # !A1L552 & (sum102[3]);


--sum101[3] is sum101[3]
sum101[3] = A1L552 & A1L701 # !A1L552 & (sum101[3]);


--sum102[2] is sum102[2]
sum102[2] = A1L552 & A1L58 # !A1L552 & (sum102[2]);


--sum101[2] is sum101[2]
sum101[2] = A1L552 & A1L501 # !A1L552 & (sum101[2]);


--sum102[1] is sum102[1]
sum102[1] = A1L552 & A1L38 # !A1L552 & (sum102[1]);


--sum101[1] is sum101[1]
sum101[1] = A1L552 & A1L301 # !A1L552 & (sum101[1]);


--sum102[0] is sum102[0]
sum102[0] = A1L552 & A1L18 # !A1L552 & (sum102[0]);


--sum101[0] is sum101[0]
sum101[0] = A1L552 & A1L101 # !A1L552 & (sum101[0]);


--A1L121 is add~1943
A1L121 = sum96[0] & (sum95[0] $ VCC) # !sum96[0] & sum95[0] & VCC;

--A1L221 is add~1944
A1L221 = CARRY(sum96[0] & sum95[0]);


--A1L321 is add~1945
A1L321 = sum96[1] & (sum95[1] & A1L221 & VCC # !sum95[1] & !A1L221) # !sum96[1] & (sum95[1] & !A1L221 # !sum95[1] & (A1L221 # GND));

--A1L421 is add~1946
A1L421 = CARRY(sum96[1] & !sum95[1] & !A1L221 # !sum96[1] & (!A1L221 # !sum95[1]));


--A1L521 is add~1947
A1L521 = (sum96[2] $ sum95[2] $ !A1L421) # GND;

--A1L621 is add~1948
A1L621 = CARRY(sum96[2] & (sum95[2] # !A1L421) # !sum96[2] & sum95[2] & !A1L421);


--A1L721 is add~1949
A1L721 = sum96[3] & (sum95[3] & A1L621 & VCC # !sum95[3] & !A1L621) # !sum96[3] & (sum95[3] & !A1L621 # !sum95[3] & (A1L621 # GND));

--A1L821 is add~1950
A1L821 = CARRY(sum96[3] & !sum95[3] & !A1L621 # !sum96[3] & (!A1L621 # !sum95[3]));


--A1L921 is add~1951
A1L921 = (sum96[4] $ sum95[4] $ !A1L821) # GND;

--A1L031 is add~1952
A1L031 = CARRY(sum96[4] & (sum95[4] # !A1L821) # !sum96[4] & sum95[4] & !A1L821);


--A1L131 is add~1953
A1L131 = sum96[5] & (sum95[5] & A1L031 & VCC # !sum95[5] & !A1L031) # !sum96[5] & (sum95[5] & !A1L031 # !sum95[5] & (A1L031 # GND));

--A1L231 is add~1954
A1L231 = CARRY(sum96[5] & !sum95[5] & !A1L031 # !sum96[5] & (!A1L031 # !sum95[5]));


--A1L331 is add~1955
A1L331 = (sum96[6] $ sum95[6] $ !A1L231) # GND;

--A1L431 is add~1956
A1L431 = CARRY(sum96[6] & (sum95[6] # !A1L231) # !sum96[6] & sum95[6] & !A1L231);


--A1L531 is add~1957
A1L531 = sum96[7] & (sum95[7] & A1L431 & VCC # !sum95[7] & !A1L431) # !sum96[7] & (sum95[7] & !A1L431 # !sum95[7] & (A1L431 # GND));

--A1L631 is add~1958
A1L631 = CARRY(sum96[7] & !sum95[7] & !A1L431 # !sum96[7] & (!A1L431 # !sum95[7]));


--A1L731 is add~1959
A1L731 = sum95[8] & (A1L631 $ GND) # !sum95[8] & !A1L631 & VCC;

--A1L831 is add~1960
A1L831 = CARRY(sum95[8] & !A1L631);


--A1L931 is add~1961
A1L931 = A1L831;


--sum103[9] is sum103[9]
sum103[9] = A1L552 & A1L931 # !A1L552 & (sum103[9]);


--sum103[8] is sum103[8]
sum103[8] = A1L552 & A1L731 # !A1L552 & (sum103[8]);


--sum103[7] is sum103[7]
sum103[7] = A1L552 & A1L531 # !A1L552 & (sum103[7]);


--sum103[6] is sum103[6]
sum103[6] = A1L552 & A1L331 # !A1L552 & (sum103[6]);


--sum103[5] is sum103[5]
sum103[5] = A1L552 & A1L131 # !A1L552 & (sum103[5]);


--sum103[4] is sum103[4]
sum103[4] = A1L552 & A1L921 # !A1L552 & (sum103[4]);


--sum103[3] is sum103[3]
sum103[3] = A1L552 & A1L721 # !A1L552 & (sum103[3]);


--sum103[2] is sum103[2]
sum103[2] = A1L552 & A1L521 # !A1L552 & (sum103[2]);


--sum103[1] is sum103[1]
sum103[1] = A1L552 & A1L321 # !A1L552 & (sum103[1]);


--sum103[0] is sum103[0]
sum103[0] = A1L552 & A1L121 # !A1L552 & (sum103[0]);


--sum[9] is sum[9]
sum[9] = !A1L752 & (A1L452 & A1L71 # !A1L452 & (sum[9]));


--sum[8] is sum[8]
sum[8] = !A1L752 & (A1L452 & A1L51 # !A1L452 & (sum[8]));


--sum[7] is sum[7]
sum[7] = !A1L752 & (A1L452 & A1L31 # !A1L452 & (sum[7]));


--sum[6] is sum[6]
sum[6] = !A1L752 & (A1L452 & A1L11 # !A1L452 & (sum[6]));


--sum[5] is sum[5]
sum[5] = !A1L752 & (A1L452 & A1L9 # !A1L452 & (sum[5]));


--sum[4] is sum[4]
sum[4] = !A1L752 & (A1L452 & A1L7 # !A1L452 & (sum[4]));


--sum[3] is sum[3]
sum[3] = !A1L752 & (A1L452 & A1L5 # !A1L452 & (sum[3]));


--sum[2] is sum[2]
sum[2] = !A1L752 & (A1L452 & A1L3 # !A1L452 & (sum[2]));


--sum[1] is sum[1]
sum[1] = !A1L752 & (A1L452 & A1L1 # !A1L452 & (sum[1]));


--sum[0] is sum[0]
sum[0] = !A1L752 & (A1L452 & sum104[0] # !A1L452 & (sum[0]));


--A1L141 is add~1963
A1L141 = q7[0] & (q6[0] $ VCC) # !q7[0] & q6[0] & VCC;

--A1L241 is add~1964
A1L241 = CARRY(q7[0] & q6[0]);


--A1L341 is add~1965
A1L341 = q7[1] & (q6[1] & A1L241 & VCC # !q6[1] & !A1L241) # !q7[1] & (q6[1] & !A1L241 # !q6[1] & (A1L241 # GND));

--A1L441 is add~1966
A1L441 = CARRY(q7[1] & !q6[1] & !A1L241 # !q7[1] & (!A1L241 # !q6[1]));


--A1L541 is add~1967
A1L541 = (q7[2] $ q6[2] $ !A1L441) # GND;

--A1L641 is add~1968
A1L641 = CARRY(q7[2] & (q6[2] # !A1L441) # !q7[2] & q6[2] & !A1L441);


--A1L741 is add~1969
A1L741 = q7[3] & (q6[3] & A1L641 & VCC # !q6[3] & !A1L641) # !q7[3] & (q6[3] & !A1L641 # !q6[3] & (A1L641 # GND));

--A1L841 is add~1970
A1L841 = CARRY(q7[3] & !q6[3] & !A1L641 # !q7[3] & (!A1L641 # !q6[3]));


--A1L941 is add~1971
A1L941 = (q7[4] $ q6[4] $ !A1L841) # GND;

--A1L051 is add~1972
A1L051 = CARRY(q7[4] & (q6[4] # !A1L841) # !q7[4] & q6[4] & !A1L841);


--A1L151 is add~1973
A1L151 = q7[5] & (q6[5] & A1L051 & VCC # !q6[5] & !A1L051) # !q7[5] & (q6[5] & !A1L051 # !q6[5] & (A1L051 # GND));

--A1L251 is add~1974
A1L251 = CARRY(q7[5] & !q6[5] & !A1L051 # !q7[5] & (!A1L051 # !q6[5]));


--A1L351 is add~1975
A1L351 = (q7[6] $ q6[6] $ !A1L251) # GND;

--A1L451 is add~1976
A1L451 = CARRY(q7[6] & (q6[6] # !A1L251) # !q7[6] & q6[6] & !A1L251);


--A1L551 is add~1977
A1L551 = q7[7] & (q6[7] & A1L451 & VCC # !q6[7] & !A1L451) # !q7[7] & (q6[7] & !A1L451 # !q6[7] & (A1L451 # GND));

--A1L651 is add~1978
A1L651 = CARRY(q7[7] & !q6[7] & !A1L451 # !q7[7] & (!A1L451 # !q6[7]));


--A1L751 is add~1979
A1L751 = !A1L651;


--sum94[8] is sum94[8]
sum94[8] = A1L552 & A1L751 # !A1L552 & (sum94[8]);


--A1L951 is add~1981
A1L951 = q5[0] & (q4[0] $ VCC) # !q5[0] & q4[0] & VCC;

--A1L061 is add~1982
A1L061 = CARRY(q5[0] & q4[0]);


--A1L161 is add~1983
A1L161 = q5[1] & (q4[1] & A1L061 & VCC # !q4[1] & !A1L061) # !q5[1] & (q4[1] & !A1L061 # !q4[1] & (A1L061 # GND));

--A1L261 is add~1984
A1L261 = CARRY(q5[1] & !q4[1] & !A1L061 # !q5[1] & (!A1L061 # !q4[1]));


--A1L361 is add~1985
A1L361 = (q5[2] $ q4[2] $ !A1L261) # GND;

--A1L461 is add~1986
A1L461 = CARRY(q5[2] & (q4[2] # !A1L261) # !q5[2] & q4[2] & !A1L261);


--A1L561 is add~1987
A1L561 = q5[3] & (q4[3] & A1L461 & VCC # !q4[3] & !A1L461) # !q5[3] & (q4[3] & !A1L461 # !q4[3] & (A1L461 # GND));

--A1L661 is add~1988
A1L661 = CARRY(q5[3] & !q4[3] & !A1L461 # !q5[3] & (!A1L461 # !q4[3]));


--A1L761 is add~1989
A1L761 = (q5[4] $ q4[4] $ !A1L661) # GND;

--A1L861 is add~1990
A1L861 = CARRY(q5[4] & (q4[4] # !A1L661) # !q5[4] & q4[4] & !A1L661);


--A1L961 is add~1991
A1L961 = q5[5] & (q4[5] & A1L861 & VCC # !q4[5] & !A1L861) # !q5[5] & (q4[5] & !A1L861 # !q4[5] & (A1L861 # GND));

--A1L071 is add~1992
A1L071 = CARRY(q5[5] & !q4[5] & !A1L861 # !q5[5] & (!A1L861 # !q4[5]));


--A1L171 is add~1993
A1L171 = (q5[6] $ q4[6] $ !A1L071) # GND;

--A1L271 is add~1994
A1L271 = CARRY(q5[6] & (q4[6] # !A1L071) # !q5[6] & q4[6] & !A1L071);


--A1L371 is add~1995
A1L371 = q5[7] & (q4[7] & A1L271 & VCC # !q4[7] & !A1L271) # !q5[7] & (q4[7] & !A1L271 # !q4[7] & (A1L271 # GND));

--A1L471 is add~1996
A1L471 = CARRY(q5[7] & !q4[7] & !A1L271 # !q5[7] & (!A1L271 # !q4[7]));


--A1L571 is add~1997
A1L571 = !A1L471;


--sum93[8] is sum93[8]
sum93[8] = A1L552 & A1L571 # !A1L552 & (sum93[8]);


--sum94[7] is sum94[7]
sum94[7] = A1L552 & A1L551 # !A1L552 & (sum94[7]);


--sum93[7] is sum93[7]
sum93[7] = A1L552 & A1L371 # !A1L552 & (sum93[7]);


--sum94[6] is sum94[6]
sum94[6] = A1L552 & A1L351 # !A1L552 & (sum94[6]);


--sum93[6] is sum93[6]
sum93[6] = A1L552 & A1L171 # !A1L552 & (sum93[6]);


--sum94[5] is sum94[5]
sum94[5] = A1L552 & A1L151 # !A1L552 & (sum94[5]);


--sum93[5] is sum93[5]
sum93[5] = A1L552 & A1L961 # !A1L552 & (sum93[5]);


--sum94[4] is sum94[4]
sum94[4] = A1L552 & A1L941 # !A1L552 & (sum94[4]);


--sum93[4] is sum93[4]
sum93[4] = A1L552 & A1L761 # !A1L552 & (sum93[4]);


--sum94[3] is sum94[3]
sum94[3] = A1L552 & A1L741 # !A1L552 & (sum94[3]);


--sum93[3] is sum93[3]
sum93[3] = A1L552 & A1L561 # !A1L552 & (sum93[3]);


--sum94[2] is sum94[2]
sum94[2] = A1L552 & A1L541 # !A1L552 & (sum94[2]);


--sum93[2] is sum93[2]
sum93[2] = A1L552 & A1L361 # !A1L552 & (sum93[2]);


--sum94[1] is sum94[1]
sum94[1] = A1L552 & A1L341 # !A1L552 & (sum94[1]);


--sum93[1] is sum93[1]
sum93[1] = A1L552 & A1L161 # !A1L552 & (sum93[1]);


--sum94[0] is sum94[0]
sum94[0] = A1L552 & A1L141 # !A1L552 & (sum94[0]);


--sum93[0] is sum93[0]
sum93[0] = A1L552 & A1L951 # !A1L552 & (sum93[0]);


--A1L771 is add~1999
A1L771 = q3[0] & (q2[0] $ VCC) # !q3[0] & q2[0] & VCC;

--A1L871 is add~2000
A1L871 = CARRY(q3[0] & q2[0]);


--A1L971 is add~2001
A1L971 = q3[1] & (q2[1] & A1L871 & VCC # !q2[1] & !A1L871) # !q3[1] & (q2[1] & !A1L871 # !q2[1] & (A1L871 # GND));

--A1L081 is add~2002
A1L081 = CARRY(q3[1] & !q2[1] & !A1L871 # !q3[1] & (!A1L871 # !q2[1]));


--A1L181 is add~2003
A1L181 = (q3[2] $ q2[2] $ !A1L081) # GND;

--A1L281 is add~2004
A1L281 = CARRY(q3[2] & (q2[2] # !A1L081) # !q3[2] & q2[2] & !A1L081);


--A1L381 is add~2005
A1L381 = q3[3] & (q2[3] & A1L281 & VCC # !q2[3] & !A1L281) # !q3[3] & (q2[3] & !A1L281 # !q2[3] & (A1L281 # GND));

--A1L481 is add~2006
A1L481 = CARRY(q3[3] & !q2[3] & !A1L281 # !q3[3] & (!A1L281 # !q2[3]));


--A1L581 is add~2007
A1L581 = (q3[4] $ q2[4] $ !A1L481) # GND;

--A1L681 is add~2008
A1L681 = CARRY(q3[4] & (q2[4] # !A1L481) # !q3[4] & q2[4] & !A1L481);


--A1L781 is add~2009
A1L781 = q3[5] & (q2[5] & A1L681 & VCC # !q2[5] & !A1L681) # !q3[5] & (q2[5] & !A1L681 # !q2[5] & (A1L681 # GND));

--A1L881 is add~2010
A1L881 = CARRY(q3[5] & !q2[5] & !A1L681 # !q3[5] & (!A1L681 # !q2[5]));


--A1L981 is add~2011
A1L981 = (q3[6] $ q2[6] $ !A1L881) # GND;

--A1L091 is add~2012
A1L091 = CARRY(q3[6] & (q2[6] # !A1L881) # !q3[6] & q2[6] & !A1L881);


--A1L191 is add~2013
A1L191 = q3[7] & (q2[7] & A1L091 & VCC # !q2[7] & !A1L091) # !q3[7] & (q2[7] & !A1L091 # !q2[7] & (A1L091 # GND));

--A1L291 is add~2014
A1L291 = CARRY(q3[7] & !q2[7] & !A1L091 # !q3[7] & (!A1L091 # !q2[7]));


--A1L391 is add~2015
A1L391 = !A1L291;


--sum92[8] is sum92[8]
sum92[8] = A1L552 & A1L391 # !A1L552 & (sum92[8]);


--A1L591 is add~2017
A1L591 = q1[0] & (q0[0] $ VCC) # !q1[0] & q0[0] & VCC;

--A1L691 is add~2018
A1L691 = CARRY(q1[0] & q0[0]);


--A1L791 is add~2019
A1L791 = q1[1] & (q0[1] & A1L691 & VCC # !q0[1] & !A1L691) # !q1[1] & (q0[1] & !A1L691 # !q0[1] & (A1L691 # GND));

--A1L891 is add~2020
A1L891 = CARRY(q1[1] & !q0[1] & !A1L691 # !q1[1] & (!A1L691 # !q0[1]));


--A1L991 is add~2021
A1L991 = (q1[2] $ q0[2] $ !A1L891) # GND;

--A1L002 is add~2022
A1L002 = CARRY(q1[2] & (q0[2] # !A1L891) # !q1[2] & q0[2] & !A1L891);


--A1L102 is add~2023
A1L102 = q1[3] & (q0[3] & A1L002 & VCC # !q0[3] & !A1L002) # !q1[3] & (q0[3] & !A1L002 # !q0[3] & (A1L002 # GND));

--A1L202 is add~2024
A1L202 = CARRY(q1[3] & !q0[3] & !A1L002 # !q1[3] & (!A1L002 # !q0[3]));


--A1L302 is add~2025
A1L302 = (q1[4] $ q0[4] $ !A1L202) # GND;

--A1L402 is add~2026
A1L402 = CARRY(q1[4] & (q0[4] # !A1L202) # !q1[4] & q0[4] & !A1L202);


--A1L502 is add~2027
A1L502 = q1[5] & (q0[5] & A1L402 & VCC # !q0[5] & !A1L402) # !q1[5] & (q0[5] & !A1L402 # !q0[5] & (A1L402 # GND));

--A1L602 is add~2028
A1L602 = CARRY(q1[5] & !q0[5] & !A1L402 # !q1[5] & (!A1L402 # !q0[5]));


--A1L702 is add~2029
A1L702 = (q1[6] $ q0[6] $ !A1L602) # GND;

--A1L802 is add~2030
A1L802 = CARRY(q1[6] & (q0[6] # !A1L602) # !q1[6] & q0[6] & !A1L602);


--A1L902 is add~2031
A1L902 = q1[7] & (q0[7] & A1L802 & VCC # !q0[7] & !A1L802) # !q1[7] & (q0[7] & !A1L802 # !q0[7] & (A1L802 # GND));

--A1L012 is add~2032
A1L012 = CARRY(q1[7] & !q0[7] & !A1L802 # !q1[7] & (!A1L802 # !q0[7]));


--A1L112 is add~2033
A1L112 = !A1L012;


--sum91[8] is sum91[8]
sum91[8] = A1L552 & A1L112 # !A1L552 & (sum91[8]);


--sum92[7] is sum92[7]
sum92[7] = A1L552 & A1L191 # !A1L552 & (sum92[7]);


--sum91[7] is sum91[7]
sum91[7] = A1L552 & A1L902 # !A1L552 & (sum91[7]);


--sum92[6] is sum92[6]
sum92[6] = A1L552 & A1L981 # !A1L552 & (sum92[6]);


--sum91[6] is sum91[6]
sum91[6] = A1L552 & A1L702 # !A1L552 & (sum91[6]);


--sum92[5] is sum92[5]
sum92[5] = A1L552 & A1L781 # !A1L552 & (sum92[5]);


--sum91[5] is sum91[5]
sum91[5] = A1L552 & A1L502 # !A1L552 & (sum91[5]);


--sum92[4] is sum92[4]
sum92[4] = A1L552 & A1L581 # !A1L552 & (sum92[4]);


--sum91[4] is sum91[4]
sum91[4] = A1L552 & A1L302 # !A1L552 & (sum91[4]);


--sum92[3] is sum92[3]
sum92[3] = A1L552 & A1L381 # !A1L552 & (sum92[3]);


--sum91[3] is sum91[3]
sum91[3] = A1L552 & A1L102 # !A1L552 & (sum91[3]);


--sum92[2] is sum92[2]
sum92[2] = A1L552 & A1L181 # !A1L552 & (sum92[2]);


--sum91[2] is sum91[2]
sum91[2] = A1L552 & A1L991 # !A1L552 & (sum91[2]);


--sum92[1] is sum92[1]
sum92[1] = A1L552 & A1L971 # !A1L552 & (sum92[1]);


--sum91[1] is sum91[1]
sum91[1] = A1L552 & A1L791 # !A1L552 & (sum91[1]);


--sum92[0] is sum92[0]
sum92[0] = A1L552 & A1L771 # !A1L552 & (sum92[0]);


--sum91[0] is sum91[0]
sum91[0] = A1L552 & A1L591 # !A1L552 & (sum91[0]);


--A1L312 is add~2035
A1L312 = q9[0] & (q8[0] $ VCC) # !q9[0] & q8[0] & VCC;

--A1L412 is add~2036
A1L412 = CARRY(q9[0] & q8[0]);


--A1L512 is add~2037
A1L512 = q9[1] & (q8[1] & A1L412 & VCC # !q8[1] & !A1L412) # !q9[1] & (q8[1] & !A1L412 # !q8[1] & (A1L412 # GND));

--A1L612 is add~2038
A1L612 = CARRY(q9[1] & !q8[1] & !A1L412 # !q9[1] & (!A1L412 # !q8[1]));


--A1L712 is add~2039
A1L712 = (q9[2] $ q8[2] $ !A1L612) # GND;

--A1L812 is add~2040
A1L812 = CARRY(q9[2] & (q8[2] # !A1L612) # !q9[2] & q8[2] & !A1L612);


--A1L912 is add~2041
A1L912 = q9[3] & (q8[3] & A1L812 & VCC # !q8[3] & !A1L812) # !q9[3] & (q8[3] & !A1L812 # !q8[3] & (A1L812 # GND));

--A1L022 is add~2042
A1L022 = CARRY(q9[3] & !q8[3] & !A1L812 # !q9[3] & (!A1L812 # !q8[3]));


--A1L122 is add~2043
A1L122 = (q9[4] $ q8[4] $ !A1L022) # GND;

--A1L222 is add~2044
A1L222 = CARRY(q9[4] & (q8[4] # !A1L022) # !q9[4] & q8[4] & !A1L022);


--A1L322 is add~2045
A1L322 = q9[5] & (q8[5] & A1L222 & VCC # !q8[5] & !A1L222) # !q9[5] & (q8[5] & !A1L222 # !q8[5] & (A1L222 # GND));

--A1L422 is add~2046
A1L422 = CARRY(q9[5] & !q8[5] & !A1L222 # !q9[5] & (!A1L222 # !q8[5]));


--A1L522 is add~2047
A1L522 = (q9[6] $ q8[6] $ !A1L422) # GND;

--A1L622 is add~2048
A1L622 = CARRY(q9[6] & (q8[6] # !A1L422) # !q9[6] & q8[6] & !A1L422);


--A1L722 is add~2049
A1L722 = q9[7] & (q8[7] & A1L622 & VCC # !q8[7] & !A1L622) # !q9[7] & (q8[7] & !A1L622 # !q8[7] & (A1L622 # GND));

--A1L822 is add~2050
A1L822 = CARRY(q9[7] & !q8[7] & !A1L622 # !q9[7] & (!A1L622 # !q8[7]));


--A1L922 is add~2051
A1L922 = !A1L822;


--sum95[8] is sum95[8]
sum95[8] = A1L552 & A1L922 # !A1L552 & (sum95[8]);


--sum96[7] is sum96[7]
sum96[7] = A1L552 & q10[7] # !A1L552 & (sum96[7]);


--sum95[7] is sum95[7]
sum95[7] = A1L552 & A1L722 # !A1L552 & (sum95[7]);


--sum96[6] is sum96[6]
sum96[6] = A1L552 & q10[6] # !A1L552 & (sum96[6]);


--sum95[6] is sum95[6]
sum95[6] = A1L552 & A1L522 # !A1L552 & (sum95[6]);


--sum96[5] is sum96[5]
sum96[5] = A1L552 & q10[5] # !A1L552 & (sum96[5]);